# whale-docgen-render

> 财鲸组件文档渲染

Latest version **0.1.6** (published 2021-08-04) · MIT license · 0 weekly downloads

## Install

```sh
npm install whale-docgen-render
pnpm add whale-docgen-render
yarn add whale-docgen-render
bun add whale-docgen-render
```

## Health

**Score 20/100 (F)** — status: abandoned.

Positive: esm support; no vulnerabilities.

Warnings: low downloads; no types; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.1.6 |
| Published | 2021-08-04 |
| First published | 2021-08-04 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | ESM + CommonJS |
| Dependencies | 9 |
| Unpacked size | 4.9 MB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Maintainers | x_xsp |
| Keywords | ice, react, component |

## Links

- npm: https://www.npmjs.com/package/whale-docgen-render
- Homepage: https://unpkg.com/whale-docgen-render@0.1.6/build/index.html
- npm.io page: https://npm.io/package/whale-docgen-render

## Dependencies (9)

- [doctrine](https://npm.io/package/doctrine.md) ^3.0.0
- [prop-types](https://npm.io/package/prop-types.md) ^15.5.8
- [remark-gfm](https://npm.io/package/remark-gfm.md) ^1.0.0
- [mdast-builder](https://npm.io/package/mdast-builder.md) ^1.1.1
- [react-markdown](https://npm.io/package/react-markdown.md) ^5.0.3
- [whale-docgen-ts](https://npm.io/package/whale-docgen-ts.md) 0.1.6
- [jsdoc-to-markdown](https://npm.io/package/jsdoc-to-markdown.md) ^6.0.1
- [github-markdown-css](https://npm.io/package/github-markdown-css.md) ^4.0.0
- [react-syntax-highlighter](https://npm.io/package/react-syntax-highlighter.md) ^15.4.2

## Alternatives

- [mobx-react](https://npm.io/package/mobx-react.md) — 2.8M weekly downloads
- [rc-tree](https://npm.io/package/rc-tree.md) — 2.6M weekly downloads
- [@react-oauth/google](https://npm.io/package/@react-oauth/google.md) — 1.3M weekly downloads
- [@wagmi/connectors](https://npm.io/package/@wagmi/connectors.md) — 877.0K weekly downloads
- [vee-validate](https://npm.io/package/vee-validate.md) — 836.4K weekly downloads

## Recent versions

- 0.1.6 (latest) — 2021-08-04
- 0.1.6-alpha.1 — 2021-08-04

## README

# whale-docgen-render

[![TNPM version](https://badgen.net/badge/tnpm/v0.1.2)](https://npm.alibaba-inc.com/package/whale-docgen-render)
[![TNPM downloads](https://npm.alibaba-inc.com/badge/d/whale-docgen-render.svg)](https://npm.alibaba-inc.com/package/whale-docgen-render)
[![提Bug](https://badgen.net/badge/icon/%E6%8F%90Bug?icon=gitlab&label&color=red)](https://gitlab.alibaba-inc.com/whale/mobile-materials//issues/new?issue%5Btitle%5D=%5BBug%5DDocStructure%3A%20&issue%5Bdescription%5D=%23%23%23%20%E7%8E%AF%E5%A2%83%E4%BF%A1%E6%81%AF%0A%0A-%20%E7%BB%84%E4%BB%B6%E5%90%8D%E7%A7%B0%EF%BC%9A%20%E8%B4%A2%E9%B2%B8%E7%BB%84%E4%BB%B6%E6%96%87%E6%A1%A3%E6%B8%B2%E6%9F%93%0A-%20%E7%BB%84%E4%BB%B6%E7%89%88%E6%9C%AC%EF%BC%9A%200.1.2%0A%0A%3C%21--%20%E5%9C%A8%E6%AD%A4%E6%8F%8F%E8%BF%B0Bug%20--%3E%0A%0A%23%23%23%20%E5%BD%93%E5%89%8D%E8%A1%8C%E4%B8%BA%0A%0A%23%23%23%20%E6%9C%9F%E6%9C%9B%E8%A1%8C%E4%B8%BA%0A%0A%23%23%23%20%E5%A4%8D%E7%8E%B0%E6%96%B9%E5%BC%8F%0A&issue%5Bissuable_template%5D=bug "提Bug")
[![提需求](https://badgen.net/badge/icon/%E6%8F%90%E9%9C%80%E6%B1%82?icon=gitlab&label&color=cyan)](https://gitlab.alibaba-inc.com/whale/mobile-materials//issues/new?issue%5Btitle%5D=%5B%E9%9C%80%E6%B1%82%5DDocStructure%3A%20&issue%5Bdescription%5D=%23%23%23%20%E7%8E%AF%E5%A2%83%E4%BF%A1%E6%81%AF%0A%0A-%20%E7%BB%84%E4%BB%B6%E5%90%8D%E7%A7%B0%3A%20DocStructure%20%E8%B4%A2%E9%B2%B8%E7%BB%84%E4%BB%B6%E6%96%87%E6%A1%A3%E6%B8%B2%E6%9F%93%0A-%20%E7%BB%84%E4%BB%B6%E7%89%88%E6%9C%AC%3A%200.1.2%0A%0A%3C%21--%20%E5%9C%A8%E6%AD%A4%E6%8F%8F%E8%BF%B0%E9%9C%80%E6%B1%82%20--%3E%0A%0A%23%23%23%20%E6%9C%9F%E6%9C%9B%E8%A1%8C%E4%B8%BA%0A%0A%23%23%23%20UI%E6%88%AA%E5%9B%BE%28%E5%A6%82%E6%9E%9C%E6%9C%89%E8%AE%BE%E8%AE%A1%E7%A8%BF%E8%AF%B7%E9%99%84%E4%B8%8A%29%0A&issue%5Bissuable_template%5D=enhancement "提需求")

财鲸组件文档渲染

## 安装方法

```sh
$ tnpm install whale-docgen-render --save
```

[如何iceworks中使用组件](https://yuque.antfin-inc.com/bp-xt-dt/battle/components_used_in_iceworks "如何iceworks中使用组件")

## API

### DocStructureCollapse

折叠样式文档组件。

| 参数           | 说明               | 类型    | 可选值 | 默认值 |
| -------------- | ------------------ | ------- | ------ | ------ |
| props _(必填)_ | 需要渲染的组件字段 | WmProps |        |        |

### DocStructureTypesCollapse

折叠样式文档组件。

| 参数           | 说明               | 类型              | 可选值 | 默认值 |
| -------------- | ------------------ | ----------------- | ------ | ------ |
| types _(必填)_ | 需要渲染的组件字段 | WmPropItemType\[] |        |        |

### DocStructureTable

表格样式文档组件。

| 参数                           | 说明                                                                                                                                                                                                                                           | 类型                                                                                                                                                                                                                                                                                           | 可选值                                                                                                                                                   | 默认值 |
| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ |
| props _(必填)_                 | 需要渲染的组件字段                                                                                                                                                                                                                             | WmProps                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| prefix                         | 样式类名的品牌前缀                                                                                                                                                                                                                             | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| size                           | 尺寸 small为紧凑模式                                                                                                                                                                                                                           | "small" \| "medium"                                                                                                                                                                                                                                                                            | "small", "medium"                                                                                                                                        |        |
| className                      | 自定义类名                                                                                                                                                                                                                                     | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| style                          | 自定义内联样式                                                                                                                                                                                                                                 | CSSProperties                                                                                                                                                                                                                                                                                  |                                                                                                                                                          |        |
| columns                        |                                                                                                                                                                                                                                                | any\[]                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| tableLayout                    | 表格元素的 table-layout 属性，设为 fixed 表示内容不会影响列的布局                                                                                                                                                                              | "fixed" \| "auto"                                                                                                                                                                                                                                                                              | "fixed", "auto"                                                                                                                                          |        |
| tableWidth                     | 表格的总长度，可以这么用：设置表格总长度 、设置部分列的宽度，这样表格会按照剩余空间大小，自动其他列分配宽度                                                                                                                                    | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| dataSource                     | 表格展示的数据源                                                                                                                                                                                                                               | any\[]                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| onRowClick                     | 点击表格每一行触发的事件                                                                                                                                                                                                                       | (record: any, index: number, e: MouseEvent&lt;Element, MouseEvent>) => void                                                                                                                                                                                                                    |                                                                                                                                                          |        |
| onRowMouseEnter                | 悬浮在表格每一行的时候触发的事件                                                                                                                                                                                                               | (record: any, index: number, e: MouseEvent&lt;Element, MouseEvent>) => void                                                                                                                                                                                                                    |                                                                                                                                                          |        |
| onRowMouseLeave                | 离开表格每一行的时候触发的事件                                                                                                                                                                                                                 | (record: any, index: number, e: MouseEvent&lt;Element, MouseEvent>) => void                                                                                                                                                                                                                    |                                                                                                                                                          |        |
| onSort                         | 点击列排序触发的事件                                                                                                                                                                                                                           | (dataIndex: string, order: string) => void                                                                                                                                                                                                                                                     |                                                                                                                                                          |        |
| onFilter                       | 点击过滤确认按钮触发的事件                                                                                                                                                                                                                     | (filterParams: any) => void                                                                                                                                                                                                                                                                    |                                                                                                                                                          |        |
| onResizeChange                 | 重设列尺寸的时候触发的事件                                                                                                                                                                                                                     | (dataIndex: string, value: number) => void                                                                                                                                                                                                                                                     |                                                                                                                                                          |        |
| getRowProps                    | 设置每一行的属性，如果返回值和其他针对行操作的属性冲突则无效。                                                                                                                                                                                 | (record: any, index: number) => any                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| rowProps                       |                                                                                                                                                                                                                                                | (record: any, index: number) => any                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| getCellProps                   | 设置单元格的属性，通过该属性可以进行合并单元格                                                                                                                                                                                                 | (rowIndex: number, colIndex: number, dataIndex: string, record: any) => any                                                                                                                                                                                                                    |                                                                                                                                                          |        |
| cellProps                      |                                                                                                                                                                                                                                                | (rowIndex: number, colIndex: number, dataIndex: string, record: any) => any                                                                                                                                                                                                                    |                                                                                                                                                          |        |
| hasBorder                      | 表格是否具有边框                                                                                                                                                                                                                               | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| hasHeader                      | 表格是否具有头部                                                                                                                                                                                                                               | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| isZebra                        | 表格是否是斑马线                                                                                                                                                                                                                               | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| loading                        | 表格是否在加载中                                                                                                                                                                                                                               | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| loadingComponent               | 自定义 Loading 组件 请务必传递 props, 使用方式： loadingComponent={props => &lt;Loading {...props}/>}                                                                                                                                          | (props: LoadingProps) => ReactNode                                                                                                                                                                                                                                                             |                                                                                                                                                          |        |
| filterParams                   | 当前过滤的的keys,使用此属性可以控制表格的头部的过滤选项中哪个菜单被选中,格式为 {dataIndex: {selectedKeys:\[]}} 示例: 假设要控制dataIndex为id的列的过滤菜单中key为one的菜单项选中 \`&lt;Table filterParams={{id: {selectedKeys: \['one']}}}/>\` | { \[propName: string]: any; }                                                                                                                                                                                                                                                                  |                                                                                                                                                          |        |
| sort                           | 当前排序的字段,使用此属性可以控制表格的字段的排序,格式为{dataIndex: 'asc'}                                                                                                                                                                     | { \[propName: string]: any; }                                                                                                                                                                                                                                                                  |                                                                                                                                                          |        |
| sortIcons                      | 自定义排序按钮，例如上下排布的: \`{desc: &lt;Icon style={{top: '6px', left: '4px'}} type={'arrow-down'} size="small" />, asc: &lt;Icon style={{top: '-6px', left: '4px'}} type={'arrow-up'} size="small" />}\`                                 | { desc?: ReactNode; asc?: ReactNode; }                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| locale                         | 自定义国际化文案对象                                                                                                                                                                                                                           | { ok: string; reset: string; empty: string; asc: string; desc: string; expanded: string; folded: string; filter: string; selectAll: string; }                                                                                                                                                  |                                                                                                                                                          |        |
| emptyContent                   | 设置数据为空的时候的表格内容展现                                                                                                                                                                                                               | ReactNode                                                                                                                                                                                                                                                                                      |                                                                                                                                                          |        |
| primaryKey                     | dataSource当中数据的主键，如果给定的数据源中的属性不包含该主键，会造成选择状态全部选中                                                                                                                                                         | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| expandedRowRender              | 额外渲染行的渲染函数                                                                                                                                                                                                                           | (record: any, index: number) => ReactElement&lt;any, string \| JSXElementConstructor&lt;any>>                                                                                                                                                                                                  |                                                                                                                                                          |        |
| rowExpandable                  |                                                                                                                                                                                                                                                | (record: any) => boolean                                                                                                                                                                                                                                                                       |                                                                                                                                                          |        |
| expandedRowIndent              | 额外渲染行的缩进                                                                                                                                                                                                                               | any\[]                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| openRowKeys                    | 默认情况下展开的渲染行或者Tree, 传入此属性为受控状态                                                                                                                                                                                           | any\[]                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| hasExpandedRowCtrl             | 是否显示点击展开额外渲染行的+号按钮                                                                                                                                                                                                            | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| getExpandedColProps            | 设置额外渲染行的属性                                                                                                                                                                                                                           | &lt;IRecord extends unknown = any>(record: IRecord, index: number) => object \| Record&lt;string \| number, any>                                                                                                                                                                               |                                                                                                                                                          |        |
| onRowOpen                      | 在额外渲染行或者Tree展开或者收起的时候触发的事件                                                                                                                                                                                               | (openRowKeys: any\[], currentRowKey: string, expanded: boolean, currentRecord: any) => void                                                                                                                                                                                                    |                                                                                                                                                          |        |
| onExpandedRowClick             | 点击额外渲染行触发的事件                                                                                                                                                                                                                       | (record: any, index: number, e: MouseEvent&lt;Element, MouseEvent>) => void                                                                                                                                                                                                                    |                                                                                                                                                          |        |
| fixedHeader                    | 表头是否固定，该属性配合maxBodyHeight使用，当内容区域的高度超过maxBodyHeight的时候，在内容区域会出现滚动条                                                                                                                                     | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| maxBodyHeight                  | 最大内容区域的高度,在\`fixedHeader\`为\`true\`的时候,超过这个高度会出现滚动条                                                                                                                                                                  | string \| number                                                                                                                                                                                                                                                                               | string, number                                                                                                                                           |        |
| rowSelection                   | 是否启用选择模式                                                                                                                                                                                                                               | { getProps?: (record: any, index: number) => void; onChange?: (selectedRowKeys: any\[], records: any\[]) => void; onSelect?: (selected: boolean, record: any, records: any\[]) => void; onSelectAll?: (selected: boolean, records: any\[]) => void; ... 4 more ...; titleAddons?: () => any; } |                                                                                                                                                          |        |
| stickyHeader                   | 表头是否是sticky                                                                                                                                                                                                                               | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| offsetTop                      | 距离窗口顶部达到指定偏移量后触发                                                                                                                                                                                                               | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| affixProps                     | affix组件的的属性                                                                                                                                                                                                                              | AffixProps                                                                                                                                                                                                                                                                                     |                                                                                                                                                          |        |
| indent                         | 在tree模式下的缩进尺寸， 仅在isTree为true时候有效                                                                                                                                                                                              | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| isTree                         | 开启Table的tree模式, 接收的数据格式中包含children则渲染成tree table                                                                                                                                                                            | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| useVirtual                     | 是否开启虚拟滚动                                                                                                                                                                                                                               | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| scrollToRow                    | 滚动到指定行                                                                                                                                                                                                                                   | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| rowHeight                      | 设置行高                                                                                                                                                                                                                                       | number \| (() => void)                                                                                                                                                                                                                                                                         | number, () => void                                                                                                                                       |        |
| onBodyScroll                   | 在内容区域滚动的时候触发的函数                                                                                                                                                                                                                 | () => void                                                                                                                                                                                                                                                                                     |                                                                                                                                                          |        |
| expandedIndexSimulate          | 开启时，getExpandedColProps() / getRowProps() / expandedRowRender() 的第二个参数 index (该行所对应的序列) 将按照01,2,3,4...的顺序返回，否则返回真实index(0,2,4,6... / 1,3,5,7...)                                                              | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| crossline                      | 在 hover 时出现十字参考轴，适用于表头比较复杂，需要做表头分类的场景。                                                                                                                                                                          | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| defaultChecked                 |                                                                                                                                                                                                                                                | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| defaultValue                   |                                                                                                                                                                                                                                                | string \| number \| readonly string\[]                                                                                                                                                                                                                                                         | string, number, readonly string\[]                                                                                                                       |        |
| suppressContentEditableWarning |                                                                                                                                                                                                                                                | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| suppressHydrationWarning       |                                                                                                                                                                                                                                                | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| accessKey                      |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| contentEditable                |                                                                                                                                                                                                                                                | Booleanish \| "inherit"                                                                                                                                                                                                                                                                        | false, true, "true", "false", "inherit"                                                                                                                  |        |
| contextMenu                    |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| dir                            |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| draggable                      |                                                                                                                                                                                                                                                | Booleanish                                                                                                                                                                                                                                                                                     |                                                                                                                                                          |        |
| hidden                         |                                                                                                                                                                                                                                                | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| id                             |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| lang                           |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| placeholder                    |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| slot                           |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| spellCheck                     |                                                                                                                                                                                                                                                | Booleanish                                                                                                                                                                                                                                                                                     |                                                                                                                                                          |        |
| tabIndex                       |                                                                                                                                                                                                                                                | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| title                          |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| translate                      |                                                                                                                                                                                                                                                | "yes" \| "no"                                                                                                                                                                                                                                                                                  | "yes", "no"                                                                                                                                              |        |
| radioGroup                     |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| role                           |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| about                          |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| datatype                       |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| inlist                         |                                                                                                                                                                                                                                                | any                                                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| property                       |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| resource                       |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| typeof                         |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| vocab                          |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| autoCapitalize                 |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| autoCorrect                    |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| autoSave                       |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| color                          |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| itemProp                       |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| itemScope                      |                                                                                                                                                                                                                                                | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| itemType                       |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| itemID                         |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| itemRef                        |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| results                        |                                                                                                                                                                                                                                                | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| security                       |                                                                                                                                                                                                                                                | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| unselectable                   |                                                                                                                                                                                                                                                | "on" \| "off"                                                                                                                                                                                                                                                                                  | "on", "off"                                                                                                                                              |        |
| inputMode                      | Hints at the type of data that might be entered by the user while editing the element or its contents @see https ://html.spec.whatwg.org/multipage/interaction.html#input-modalities:-the-inputmode-attribute                                  | "none" \| "text" \| "tel" \| "url" \| "email" \| "numeric" \| "decimal" \| "search"                                                                                                                                                                                                            | "none", "text", "tel", "url", "email", "numeric", "decimal", "search"                                                                                    |        |
| is                             | Specify that a standard HTML element should behave like a defined custom built-in element @see https ://html.spec.whatwg.org/multipage/custom-elements.html#attr-is                                                                            | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-activedescendant          | Identifies the currently active element when DOM focus is on a composite widget, textbox, group, or application.                                                                                                                               | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-atomic                    | Indicates whether assistive technologies will present all, or only parts of, the changed region based on the change notifications defined by the aria-relevant attribute.                                                                      | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-autocomplete              | Indicates whether inputting text could trigger display of one or more predictions of the user's intended value for an input and specifies how predictions would be presented if they are made.                                                 | "none" \| "inline" \| "list" \| "both"                                                                                                                                                                                                                                                         | "none", "inline", "list", "both"                                                                                                                         |        |
| aria-busy                      | Indicates an element is being modified and that assistive technologies MAY want to wait until the modifications are complete before exposing them to the user.                                                                                 | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-checked                   | Indicates the current "checked" state of checkboxes, radio buttons, and other widgets. @see aria-pressed @see aria-selected.                                                                                                                   | boolean \| "true" \| "false" \| "mixed"                                                                                                                                                                                                                                                        | false, true, "true", "false", "mixed"                                                                                                                    |        |
| aria-colcount                  | Defines the total number of columns in a table, grid, or treegrid. @see aria-colindex.                                                                                                                                                         | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-colindex                  | Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid. @see aria-colcount @see aria-colspan.                                                                             | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-colspan                   | Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid. @see aria-colindex @see aria-rowspan.                                                                                                           | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-controls                  | Identifies the element (or elements) whose contents or presence are controlled by the current element. @see aria-owns.                                                                                                                         | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-current                   | Indicates the element that represents the current item within a container or set of related elements.                                                                                                                                          | boolean \| "true" \| "false" \| "page" \| "step" \| "location" \| "date" \| "time"                                                                                                                                                                                                             | false, true, "true", "false", "page", "step", "location", "date", "time"                                                                                 |        |
| aria-describedby               | Identifies the element (or elements) that describes the object. @see aria-labelledby                                                                                                                                                           | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-details                   | Identifies the element that provides a detailed, extended description for the object. @see aria-describedby.                                                                                                                                   | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-disabled                  | Indicates that the element is perceivable but disabled, so it is not editable or otherwise operable. @see aria-hidden @see aria-readonly.                                                                                                      | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-dropeffect                | Indicates what functions can be performed when a dragged object is released on the drop target. @deprecated in ARIA 1.1                                                                                                                        | "none" \| "copy" \| "execute" \| "link" \| "move" \| "popup"                                                                                                                                                                                                                                   | "none", "copy", "execute", "link", "move", "popup"                                                                                                       |        |
| aria-errormessage              | Identifies the element that provides an error message for the object. @see aria-invalid @see aria-describedby.                                                                                                                                 | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-expanded                  | Indicates whether the element, or another grouping element it controls, is currently expanded or collapsed.                                                                                                                                    | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-flowto                    | Identifies the next element (or elements) in an alternate reading order of content which, at the user's discretion, allows assistive technology to override the general default of reading in document source order.                           | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-grabbed                   | Indicates an element's "grabbed" state in a drag-and-drop operation. @deprecated in ARIA 1.1                                                                                                                                                   | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-haspopup                  | Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element.                                                                                                                 | boolean \| "true" \| "false" \| "menu" \| "listbox" \| "tree" \| "grid" \| "dialog"                                                                                                                                                                                                            | false, true, "true", "false", "menu", "listbox", "tree", "grid", "dialog"                                                                                |        |
| aria-hidden                    | Indicates whether the element is exposed to an accessibility API. @see aria-disabled.                                                                                                                                                          | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-invalid                   | Indicates the entered value does not conform to the format expected by the application. @see aria-errormessage.                                                                                                                                | boolean \| "true" \| "false" \| "grammar" \| "spelling"                                                                                                                                                                                                                                        | false, true, "true", "false", "grammar", "spelling"                                                                                                      |        |
| aria-keyshortcuts              | Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element.                                                                                                                                           | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-label                     | Defines a string value that labels the current element. @see aria-labelledby.                                                                                                                                                                  | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-labelledby                | Identifies the element (or elements) that labels the current element. @see aria-describedby.                                                                                                                                                   | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-level                     | Defines the hierarchical level of an element within a structure.                                                                                                                                                                               | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-live                      | Indicates that an element will be updated, and describes the types of updates the user agents, assistive technologies, and user can expect from the live region.                                                                               | "off" \| "assertive" \| "polite"                                                                                                                                                                                                                                                               | "off", "assertive", "polite"                                                                                                                             |        |
| aria-modal                     | Indicates whether an element is modal when displayed.                                                                                                                                                                                          | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-multiline                 | Indicates whether a text box accepts multiple lines of input or only a single line.                                                                                                                                                            | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-multiselectable           | Indicates that the user may select more than one item from the current selectable descendants.                                                                                                                                                 | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-orientation               | Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous.                                                                                                                                                     | "horizontal" \| "vertical"                                                                                                                                                                                                                                                                     | "horizontal", "vertical"                                                                                                                                 |        |
| aria-owns                      | Identifies an element (or elements) in order to define a visual, functional, or contextual parent/child relationship between DOM elements where the DOM hierarchy cannot be used to represent the relationship. @see aria-controls.            | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-placeholder               | Defines a short hint (a word or short phrase) intended to aid the user with data entry when the control has no value. A hint could be a sample value or a brief description of the expected format.                                            | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-posinset                  | Defines an element's number or position in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM. @see aria-setsize.                                                                       | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-pressed                   | Indicates the current "pressed" state of toggle buttons. @see aria-checked @see aria-selected.                                                                                                                                                 | boolean \| "true" \| "false" \| "mixed"                                                                                                                                                                                                                                                        | false, true, "true", "false", "mixed"                                                                                                                    |        |
| aria-readonly                  | Indicates that the element is not editable, but is otherwise operable. @see aria-disabled.                                                                                                                                                     | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-relevant                  | Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified. @see aria-atomic.                                                                                                       | "text" \| "additions" \| "additions removals" \| "additions text" \| "all" \| "removals" \| "removals additions" \| "removals text" \| "text additions" \| "text removals"                                                                                                                     | "text", "additions", "additions removals", "additions text", "all", "removals", "removals additions", "removals text", "text additions", "text removals" |        |
| aria-required                  | Indicates that user input is required on the element before a form may be submitted.                                                                                                                                                           | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-roledescription           | Defines a human-readable, author-localized description for the role of an element.                                                                                                                                                             | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-rowcount                  | Defines the total number of rows in a table, grid, or treegrid. @see aria-rowindex.                                                                                                                                                            | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-rowindex                  | Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid. @see aria-rowcount @see aria-rowspan.                                                                                   | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-rowspan                   | Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid. @see aria-rowindex @see aria-colspan.                                                                                                              | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-selected                  | Indicates the current "selected" state of various widgets. @see aria-checked @see aria-pressed.                                                                                                                                                | boolean \| "true" \| "false"                                                                                                                                                                                                                                                                   | false, true, "true", "false"                                                                                                                             |        |
| aria-setsize                   | Defines the number of items in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM. @see aria-posinset.                                                                                  | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-sort                      | Indicates if items in a table or grid are sorted in ascending or descending order.                                                                                                                                                             | "none" \| "ascending" \| "descending" \| "other"                                                                                                                                                                                                                                               | "none", "ascending", "descending", "other"                                                                                                               |        |
| aria-valuemax                  | Defines the maximum allowed value for a range widget.                                                                                                                                                                                          | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-valuemin                  | Defines the minimum allowed value for a range widget.                                                                                                                                                                                          | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-valuenow                  | Defines the current value for a range widget. @see aria-valuetext.                                                                                                                                                                             | number                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| aria-valuetext                 | Defines the human readable text alternative of aria-valuenow for a range widget.                                                                                                                                                               | string                                                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| dangerouslySetInnerHTML        |                                                                                                                                                                                                                                                | { \_\_html: string; }                                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onCopy                         |                                                                                                                                                                                                                                                | ClipboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onCopyCapture                  |                                                                                                                                                                                                                                                | ClipboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onCut                          |                                                                                                                                                                                                                                                | ClipboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onCutCapture                   |                                                                                                                                                                                                                                                | ClipboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onPaste                        |                                                                                                                                                                                                                                                | ClipboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onPasteCapture                 |                                                                                                                                                                                                                                                | ClipboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onCompositionEnd               |                                                                                                                                                                                                                                                | CompositionEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| onCompositionEndCapture        |                                                                                                                                                                                                                                                | CompositionEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| onCompositionStart             |                                                                                                                                                                                                                                                | CompositionEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| onCompositionStartCapture      |                                                                                                                                                                                                                                                | CompositionEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| onCompositionUpdate            |                                                                                                                                                                                                                                                | CompositionEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| onCompositionUpdateCapture     |                                                                                                                                                                                                                                                | CompositionEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| onFocus                        |                                                                                                                                                                                                                                                | FocusEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onFocusCapture                 |                                                                                                                                                                                                                                                | FocusEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onBlur                         |                                                                                                                                                                                                                                                | FocusEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onBlurCapture                  |                                                                                                                                                                                                                                                | FocusEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onChange                       |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onChangeCapture                |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onBeforeInput                  |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onBeforeInputCapture           |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onInput                        |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onInputCapture                 |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onReset                        |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onResetCapture                 |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onSubmit                       |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onSubmitCapture                |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onInvalid                      |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onInvalidCapture               |                                                                                                                                                                                                                                                | FormEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onLoad                         |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onLoadCapture                  |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onError                        |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onErrorCapture                 |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onKeyDown                      |                                                                                                                                                                                                                                                | KeyboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                           |                                                                                                                                                          |        |
| onKeyDownCapture               |                                                                                                                                                                                                                                                | KeyboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                           |                                                                                                                                                          |        |
| onKeyPress                     |                                                                                                                                                                                                                                                | KeyboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                           |                                                                                                                                                          |        |
| onKeyPressCapture              |                                                                                                                                                                                                                                                | KeyboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                           |                                                                                                                                                          |        |
| onKeyUp                        |                                                                                                                                                                                                                                                | KeyboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                           |                                                                                                                                                          |        |
| onKeyUpCapture                 |                                                                                                                                                                                                                                                | KeyboardEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                           |                                                                                                                                                          |        |
| onAbort                        |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onAbortCapture                 |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onCanPlay                      |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onCanPlayCapture               |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onCanPlayThrough               |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onCanPlayThroughCapture        |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onDurationChange               |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onDurationChangeCapture        |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onEmptied                      |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onEmptiedCapture               |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onEncrypted                    |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onEncryptedCapture             |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onEnded                        |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onEndedCapture                 |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onLoadedData                   |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onLoadedDataCapture            |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onLoadedMetadata               |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onLoadedMetadataCapture        |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onLoadStart                    |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onLoadStartCapture             |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onPause                        |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onPauseCapture                 |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onPlay                         |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onPlayCapture                  |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onPlaying                      |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onPlayingCapture               |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onProgress                     |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onProgressCapture              |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onRateChange                   |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onRateChangeCapture            |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onSeeked                       |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onSeekedCapture                |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onSeeking                      |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onSeekingCapture               |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onStalled                      |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onStalledCapture               |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onSuspend                      |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onSuspendCapture               |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onTimeUpdate                   |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onTimeUpdateCapture            |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onVolumeChange                 |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onVolumeChangeCapture          |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onWaiting                      |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onWaitingCapture               |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onAuxClick                     |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onAuxClickCapture              |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onClick                        |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onClickCapture                 |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onContextMenu                  |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onContextMenuCapture           |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onDoubleClick                  |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onDoubleClickCapture           |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onDrag                         |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragCapture                  |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragEnd                      |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragEndCapture               |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragEnter                    |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragEnterCapture             |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragExit                     |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragExitCapture              |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragLeave                    |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragLeaveCapture             |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragOver                     |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragOverCapture              |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragStart                    |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDragStartCapture             |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDrop                         |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onDropCapture                  |                                                                                                                                                                                                                                                | DragEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                               |                                                                                                                                                          |        |
| onMouseDown                    |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onMouseDownCapture             |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onMouseEnter                   |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onMouseLeave                   |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onMouseMove                    |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onMouseMoveCapture             |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onMouseOut                     |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onMouseOutCapture              |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onMouseOver                    |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onMouseOverCapture             |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onMouseUp                      |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onMouseUpCapture               |                                                                                                                                                                                                                                                | MouseEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onSelect                       |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onSelectCapture                |                                                                                                                                                                                                                                                | ReactEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onTouchCancel                  |                                                                                                                                                                                                                                                | TouchEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onTouchCancelCapture           |                                                                                                                                                                                                                                                | TouchEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onTouchEnd                     |                                                                                                                                                                                                                                                | TouchEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onTouchEndCapture              |                                                                                                                                                                                                                                                | TouchEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onTouchMove                    |                                                                                                                                                                                                                                                | TouchEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onTouchMoveCapture             |                                                                                                                                                                                                                                                | TouchEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onTouchStart                   |                                                                                                                                                                                                                                                | TouchEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onTouchStartCapture            |                                                                                                                                                                                                                                                | TouchEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onPointerDown                  |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerDownCapture           |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerMove                  |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerMoveCapture           |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerUp                    |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerUpCapture             |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerCancel                |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerCancelCapture         |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerEnter                 |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerEnterCapture          |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerLeave                 |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerLeaveCapture          |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerOver                  |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerOverCapture           |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerOut                   |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onPointerOutCapture            |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onGotPointerCapture            |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onGotPointerCaptureCapture     |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onLostPointerCapture           |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onLostPointerCaptureCapture    |                                                                                                                                                                                                                                                | PointerEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                            |                                                                                                                                                          |        |
| onScroll                       |                                                                                                                                                                                                                                                | UIEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                                 |                                                                                                                                                          |        |
| onScrollCapture                |                                                                                                                                                                                                                                                | UIEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                                 |                                                                                                                                                          |        |
| onWheel                        |                                                                                                                                                                                                                                                | WheelEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onWheelCapture                 |                                                                                                                                                                                                                                                | WheelEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                              |                                                                                                                                                          |        |
| onAnimationStart               |                                                                                                                                                                                                                                                | AnimationEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onAnimationStartCapture        |                                                                                                                                                                                                                                                | AnimationEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onAnimationEnd                 |                                                                                                                                                                                                                                                | AnimationEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onAnimationEndCapture          |                                                                                                                                                                                                                                                | AnimationEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onAnimationIteration           |                                                                                                                                                                                                                                                | AnimationEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onAnimationIterationCapture    |                                                                                                                                                                                                                                                | AnimationEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                          |                                                                                                                                                          |        |
| onTransitionEnd                |                                                                                                                                                                                                                                                | TransitionEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| onTransitionEndCapture         |                                                                                                                                                                                                                                                | TransitionEventHandler&lt;HTMLElement>                                                                                                                                                                                                                                                         |                                                                                                                                                          |        |
| pure                           | 是否开启 Pure Render 模式，会提高性能，但是也会带来副作用                                                                                                                                                                                      | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| warning                        | 是否在开发模式下显示组件属性被废弃的 warning 提示                                                                                                                                                                                              | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |
| rtl                            | 是否开启 rtl 模式                                                                                                                                                                                                                              | boolean                                                                                                                                                                                                                                                                                        |                                                                                                                                                          |        |

### DocStructureArticle

折叠样式文档组件。

| 参数           | 说明               | 类型    | 可选值 | 默认值 |
| -------------- | ------------------ | ------- | ------ | ------ |
| props _(必填)_ | 需要渲染的组件字段 | WmProps |        |        |

### DocStructurePropBlock

折叠样式文档组件。

| 参数          | 说明               | 类型       | 可选值 | 默认值 |
| ------------- | ------------------ | ---------- | ------ | ------ |
| prop _(必填)_ | 需要渲染的组件字段 | WmPropItem |        |        |

### DocStructureMarkdownRender

Markdown展示

| 参数               | 说明                               | 类型                                                                                                                                                                                                                                              | 可选值                     | 默认值 |
| ------------------ | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------- | ------ |
| className          |                                    | string                                                                                                                                                                                                                                            |                            |        |
| allowDangerousHtml |                                    | boolean                                                                                                                                                                                                                                           |                            |        |
| skipHtml           |                                    | boolean                                                                                                                                                                                                                                           |                            |        |
| disallowedTypes    |                                    | ("text" \| "list" \| "link" \| "paragraph" \| "heading" \| "thematicBreak" \| "blockquote" \| "table" \| "html" \| "code" \| "yaml" \| "definition" \| "footnoteDefinition" \| "listItem" \| "tableRow" \| ... 10 more ... \| "linkReference")\[] |                            |        |
| escapeHtml         | @deprecated use allowDangerousHtml | boolean                                                                                                                                                                                                                                           |                            |        |
| allowedTypes       |                                    | ("text" \| "list" \| "link" \| "paragraph" \| "heading" \| "thematicBreak" \| "blockquote" \| "table" \| "html" \| "code" \| "yaml" \| "definition" \| "footnoteDefinition" \| "listItem" \| "tableRow" \| ... 10 more ... \| "linkReference")\[] |                            |        |
| sourcePos          |                                    | boolean                                                                                                                                                                                                                                           |                            |        |
| includeNodeIndex   |                                    | boolean                                                                                                                                                                                                                                           |                            |        |
| rawSourcePos       |                                    | boolean                                                                                                                                                                                                                                           |                            |        |
| allowNode          |                                    | (node: Content, index: number, parent: "text" \| "list" \| "link" \| "paragraph" \| "heading" \| "thematicBreak" \| "blockquote" \| "table" \| "html" \| "code" \| "yaml" \| "definition" \| ... 13 more ... \| "linkReference") => boolean       |                            |        |
| linkTarget         |                                    | string \| LinkTargetResolver                                                                                                                                                                                                                      | string, LinkTargetResolver |        |
| transformLinkUri   |                                    | (uri: string, children?: ReactNode, title?: string) => string                                                                                                                                                                                     |                            |        |
| transformImageUri  |                                    | (uri: string, children?: ReactNode, title?: string, alt?: string) => string                                                                                                                                                                       |                            |        |
| renderers          |                                    | { \[nodeType: string]: ElementType&lt;any>; }                                                                                                                                                                                                     |                            |        |
| astPlugins         |                                    | PluggableList&lt;Settings>                                                                                                                                                                                                                        |                            |        |
| plugins            |                                    | PluggableList&lt;Settings>                                                                                                                                                                                                                        |                            |        |
| unwrapDisallowed   |                                    | boolean                                                                                                                                                                                                                                           |                            |        |

---
_Source: https://npm.io/package/whale-docgen-render · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._
