From a3054535ffb7377aef30bb09c7f5370ba26a286c Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Tue, 24 Mar 2026 14:58:27 +0100
Subject: [PATCH 01/16] feat: add mcp-server package

---
 docs/ProjectTemplates.mdx                     |   150 +-
 docs/project-templates.json                   |    82 +
 eslint.config.mjs                             |     4 +-
 .../test/SplitterLayout.spec.tsx              |     2 +-
 packages/mcp-server/.gitignore                |     9 +
 packages/mcp-server/README.md                 |   167 +
 packages/mcp-server/package.json              |    75 +
 packages/mcp-server/resources/llms.txt        |    61 +
 packages/mcp-server/scripts/bundle_docs.ts    |   172 +
 .../scripts/extract_component_descriptions.ts |   182 +
 .../scripts/fetch_upstream_skills.ts          |    79 +
 packages/mcp-server/scripts/utils/cem.ts      |   136 +
 packages/mcp-server/scripts/utils/docgen.ts   |   275 +
 packages/mcp-server/scripts/utils/text.ts     |    70 +
 packages/mcp-server/server.json               |    23 +
 packages/mcp-server/src/index.ts              |    77 +
 packages/mcp-server/src/logger.ts             |    22 +
 .../get_component_api/component-apis.json     | 34108 ++++++++++++++++
 .../get_component_api/get_component_api.ts    |   193 +
 .../documentation_sections.json               |   272 +
 .../get_documentation/get_documentation.ts    |   496 +
 .../get_public_utils/get_public_utils.ts      |   421 +
 packages/mcp-server/src/tools/index.ts        |     4 +
 .../tools/list_components/descriptions.json   |   834 +
 .../tools/list_components/list_components.ts  |   195 +
 packages/mcp-server/src/types/cem.ts          |    52 +
 .../mcp-server/src/types/component-api.ts     |    90 +
 .../mcp-server/src/types/documentation.ts     |    37 +
 packages/mcp-server/src/types/index.ts        |    18 +
 packages/mcp-server/src/utils/categories.ts   |   218 +
 packages/mcp-server/src/utils/index.ts        |    28 +
 packages/mcp-server/tsconfig.build.json       |     3 +
 packages/mcp-server/tsconfig.json             |    11 +
 tsconfig.build.json                           |     3 +
 yarn.lock                                     |  1432 +-
 35 files changed, 39830 insertions(+), 171 deletions(-)
 create mode 100644 docs/project-templates.json
 create mode 100644 packages/mcp-server/.gitignore
 create mode 100644 packages/mcp-server/README.md
 create mode 100644 packages/mcp-server/package.json
 create mode 100644 packages/mcp-server/resources/llms.txt
 create mode 100644 packages/mcp-server/scripts/bundle_docs.ts
 create mode 100644 packages/mcp-server/scripts/extract_component_descriptions.ts
 create mode 100644 packages/mcp-server/scripts/fetch_upstream_skills.ts
 create mode 100644 packages/mcp-server/scripts/utils/cem.ts
 create mode 100644 packages/mcp-server/scripts/utils/docgen.ts
 create mode 100644 packages/mcp-server/scripts/utils/text.ts
 create mode 100644 packages/mcp-server/server.json
 create mode 100644 packages/mcp-server/src/index.ts
 create mode 100644 packages/mcp-server/src/logger.ts
 create mode 100644 packages/mcp-server/src/tools/get_component_api/component-apis.json
 create mode 100644 packages/mcp-server/src/tools/get_component_api/get_component_api.ts
 create mode 100644 packages/mcp-server/src/tools/get_documentation/documentation_sections.json
 create mode 100644 packages/mcp-server/src/tools/get_documentation/get_documentation.ts
 create mode 100644 packages/mcp-server/src/tools/get_public_utils/get_public_utils.ts
 create mode 100644 packages/mcp-server/src/tools/index.ts
 create mode 100644 packages/mcp-server/src/tools/list_components/descriptions.json
 create mode 100644 packages/mcp-server/src/tools/list_components/list_components.ts
 create mode 100644 packages/mcp-server/src/types/cem.ts
 create mode 100644 packages/mcp-server/src/types/component-api.ts
 create mode 100644 packages/mcp-server/src/types/documentation.ts
 create mode 100644 packages/mcp-server/src/types/index.ts
 create mode 100644 packages/mcp-server/src/utils/categories.ts
 create mode 100644 packages/mcp-server/src/utils/index.ts
 create mode 100644 packages/mcp-server/tsconfig.build.json
 create mode 100644 packages/mcp-server/tsconfig.json

diff --git a/docs/ProjectTemplates.mdx b/docs/ProjectTemplates.mdx
index 6314a1f196d..6bd1ec52a08 100644
--- a/docs/ProjectTemplates.mdx
+++ b/docs/ProjectTemplates.mdx
@@ -1,9 +1,18 @@
-import { Footer, LabelWithWrapping, ProjectTemplate, TableOfContent } from '@sb/components';
+import { Footer, ProjectTemplate, TableOfContent } from '@sb/components';
 import NextLogo from '@sb/images/logo-nextjs.svg';
 import ReactRouterLogo from '@sb/images/logo-react-router.svg';
 import ViteLogo from '@sb/images/logo-vitejs.svg';
 import { Meta } from '@storybook/addon-docs/blocks';
 import { FlexBox, FlexBoxJustifyContent, FlexBoxWrap, Label } from '@ui5/webcomponents-react';
+import projectTemplates from './project-templates.json';
+
+export const logos = {
+  nextjs: NextLogo,
+  vite: ViteLogo,
+  'react-router': ReactRouterLogo,
+};
+
+export const repoBase = 'https://github.com/UI5/webcomponents-react/tree/main/';
 
 <Meta title="Project Templates & Examples" />
 
@@ -18,34 +27,21 @@ A curated list of minimal project templates and examples to get started using UI
 <br />
 
 <FlexBox wrap={FlexBoxWrap.Wrap} style={{ width: '100%', gap: '1rem' }} justifyContent={FlexBoxJustifyContent.Start}>
-  <ProjectTemplate
-    title={'Next.js'}
-    subtitle={'App Router'}
-    logo={NextLogo}
-    logoAttribution={'Next.js Logo. Original Source: https://vercel.com/design/brands#next-js'}
-    href={'https://github.com/UI5/webcomponents-react/tree/main/templates/nextjs-app'}
-    stackBlitzHref="https://stackblitz.com/github/UI5/webcomponents-react/tree/main/templates/nextjs-app"
-    isTypeScript
-    isTemplate
-  />
-  <ProjectTemplate
-    title={'Next.js'}
-    subtitle={'Pages Router'}
-    logo={NextLogo}
-    logoAttribution={'Next.js Logo. Original Source: https://vercel.com/design/brands#next-js'}
-    href={'https://github.com/UI5/webcomponents-react/tree/main/templates/nextjs-pages'}
-    isTypeScript
-    isTemplate
-  />
-  <ProjectTemplate
-    title={'Vite.js'}
-    logo={ViteLogo}
-    logoAttribution={'Vite.js Logo. Original Source: https://github.com/vitejs/vite/blob/main/docs/public/logo.svg '}
-    href={'https://github.com/UI5/webcomponents-react/tree/main/templates/vite-ts'}
-    isTypeScript
-    isTemplate
-    stackBlitzHref="https://stackblitz.com/github/UI5/webcomponents-react/tree/main/templates/vite-ts?file=src%2FApp.tsx"
-  />
+  {projectTemplates
+    .filter((t) => t.type === 'template')
+    .map((t) => (
+      <ProjectTemplate
+        key={t.path}
+        title={t.name}
+        subtitle={t.variant}
+        logo={logos[t.logo]}
+        logoAttribution={t.logoAttribution}
+        href={`${repoBase}${t.path}`}
+        stackBlitzHref={t.stackBlitz}
+        isTypeScript={t.typescript}
+        isTemplate
+      />
+    ))}
 </FlexBox>
 
 ## Examples
@@ -53,78 +49,30 @@ A curated list of minimal project templates and examples to get started using UI
 <br />
 
 <FlexBox wrap={FlexBoxWrap.Wrap} style={{ width: '100%', gap: '1rem' }} justifyContent={FlexBoxJustifyContent.Start}>
-  <ProjectTemplate
-    title={'Next.js'}
-    subtitle={'App Router'}
-    logo={NextLogo}
-    logoAttribution={'Next.js Logo. Original Source: https://vercel.com/design/brands#next-js'}
-    href={'https://github.com/UI5/webcomponents-react/tree/main/examples/nextjs-app'}
-    stackBlitzHref="https://stackblitz.com/github/UI5/webcomponents-react/tree/main/examples/nextjs-app"
-    isTypeScript
-  >
-    <ul>
-      <li>
-        <Label>Next.js Template using the App Router</Label>
-      </li>
-      <li>
-        <Label>Data Fetching using React Server Components</Label>
-      </li>
-    </ul>
-  </ProjectTemplate>
-  <ProjectTemplate
-    title={'Next.js'}
-    subtitle={'Pages Router'}
-    logo={NextLogo}
-    logoAttribution={'Next.js Logo. Original Source: https://vercel.com/design/brands#next-js'}
-    href={'https://github.com/UI5/webcomponents-react/tree/main/examples/nextjs-pages'}
-    isTypeScript
-  >
-    <ul>
-      <li>
-        <Label>Next.js Template using the Pages Router</Label>
-      </li>
-      <li>
-        <Label>API Routes</Label>
-      </li>
-    </ul>
-  </ProjectTemplate>
-  <ProjectTemplate
-    title={'Vite.js'}
-    logo={ViteLogo}
-    logoAttribution={'Vite.js Logo. Original Source: https://github.com/vitejs/vite/blob/main/docs/public/logo.svg '}
-    href={'https://github.com/UI5/webcomponents-react/tree/main/examples/vite-ts'}
-    isTypeScript
-    stackBlitzHref="https://stackblitz.com/github/UI5/webcomponents-react/tree/main/examples/vite-ts?file=src%2Fmain.tsx"
-  >
-    <ul>
-      <li>
-        <LabelWithWrapping>{`Routing and Data Fetching using the createBrowserRouter of React Router v7`}</LabelWithWrapping>
-      </li>
-      <li>
-        <Label>Cypress Component & E2E Test setup</Label>
-      </li>
-      <li>
-        <Label>Theming</Label>
-      </li>
-    </ul>
-  </ProjectTemplate>
-  <ProjectTemplate
-    title={'React Router v7'}
-    subtitle={'Previously: Remix Template'}
-    logo={ReactRouterLogo}
-    logoAttribution={'React Router Logo. Original Source: https://reactrouter.com'}
-    href={'https://github.com/UI5/webcomponents-react/tree/main/examples/react-router-ts'}
-    isTypeScript
-  >
-    <ul>
-      <li>
-        <Label>{`React Router v7 with server side rendering`}</Label>
-      </li>
-      <li>
-        <Label>Theming</Label>
-      </li>
-    </ul>
-  </ProjectTemplate>
+  {projectTemplates
+    .filter((t) => t.type === 'example')
+    .map((t) => (
+      <ProjectTemplate
+        key={t.path}
+        title={t.name}
+        subtitle={t.variant}
+        logo={logos[t.logo]}
+        logoAttribution={t.logoAttribution}
+        href={`${repoBase}${t.path}`}
+        stackBlitzHref={t.stackBlitz}
+        isTypeScript={t.typescript}
+      >
+        {t.features && (
+          <ul>
+            {t.features.map((f) => (
+              <li key={f}>
+                <Label>{f}</Label>
+              </li>
+            ))}
+          </ul>
+        )}
+      </ProjectTemplate>
+    ))}
 </FlexBox>
 
 <Footer />
diff --git a/docs/project-templates.json b/docs/project-templates.json
new file mode 100644
index 00000000000..9ec49c7fc33
--- /dev/null
+++ b/docs/project-templates.json
@@ -0,0 +1,82 @@
+[
+  {
+    "name": "Next.js",
+    "variant": "App Router",
+    "framework": "nextjs",
+    "type": "template",
+    "path": "templates/nextjs-app",
+    "typescript": true,
+    "stackBlitz": "https://stackblitz.com/github/UI5/webcomponents-react/tree/main/templates/nextjs-app",
+    "logo": "nextjs",
+    "logoAttribution": "Next.js Logo. Original Source: https://vercel.com/design/brands#next-js"
+  },
+  {
+    "name": "Next.js",
+    "variant": "Pages Router",
+    "framework": "nextjs",
+    "type": "template",
+    "path": "templates/nextjs-pages",
+    "typescript": true,
+    "logo": "nextjs",
+    "logoAttribution": "Next.js Logo. Original Source: https://vercel.com/design/brands#next-js"
+  },
+  {
+    "name": "Vite.js",
+    "framework": "vite",
+    "type": "template",
+    "path": "templates/vite-ts",
+    "typescript": true,
+    "stackBlitz": "https://stackblitz.com/github/UI5/webcomponents-react/tree/main/templates/vite-ts?file=src%2FApp.tsx",
+    "logo": "vite",
+    "logoAttribution": "Vite.js Logo. Original Source: https://github.com/vitejs/vite/blob/main/docs/public/logo.svg"
+  },
+  {
+    "name": "Next.js",
+    "variant": "App Router",
+    "framework": "nextjs",
+    "type": "example",
+    "path": "examples/nextjs-app",
+    "typescript": true,
+    "stackBlitz": "https://stackblitz.com/github/UI5/webcomponents-react/tree/main/examples/nextjs-app",
+    "logo": "nextjs",
+    "logoAttribution": "Next.js Logo. Original Source: https://vercel.com/design/brands#next-js",
+    "features": ["Next.js Template using the App Router", "Data Fetching using React Server Components"]
+  },
+  {
+    "name": "Next.js",
+    "variant": "Pages Router",
+    "framework": "nextjs",
+    "type": "example",
+    "path": "examples/nextjs-pages",
+    "typescript": true,
+    "logo": "nextjs",
+    "logoAttribution": "Next.js Logo. Original Source: https://vercel.com/design/brands#next-js",
+    "features": ["Next.js Template using the Pages Router", "API Routes"]
+  },
+  {
+    "name": "Vite.js",
+    "framework": "vite",
+    "type": "example",
+    "path": "examples/vite-ts",
+    "typescript": true,
+    "stackBlitz": "https://stackblitz.com/github/UI5/webcomponents-react/tree/main/examples/vite-ts?file=src%2Fmain.tsx",
+    "logo": "vite",
+    "logoAttribution": "Vite.js Logo. Original Source: https://github.com/vitejs/vite/blob/main/docs/public/logo.svg",
+    "features": [
+      "Routing and Data Fetching using the createBrowserRouter of React Router v7",
+      "Cypress Component & E2E Test setup",
+      "Theming"
+    ]
+  },
+  {
+    "name": "React Router v7",
+    "variant": "Previously: Remix Template",
+    "framework": "react-router",
+    "type": "example",
+    "path": "examples/react-router-ts",
+    "typescript": true,
+    "logo": "react-router",
+    "logoAttribution": "React Router Logo. Original Source: https://reactrouter.com",
+    "features": ["React Router v7 with server side rendering", "Theming"]
+  }
+]
diff --git a/eslint.config.mjs b/eslint.config.mjs
index cc3edac8738..087ab9fa3a3 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -20,6 +20,8 @@ const ignorePatterns = {
     'packages/compat/dist',
     'packages/main/dist',
     'packages/main/wrappers',
+    'packages/mcp-server/dist',
+    'packages/mcp-server/scripts',
     'packages/main/src/i18n/i18n-defaults.ts',
     'packages/main/src/generated',
     'packages/cypress-commands/dist',
@@ -253,7 +255,7 @@ const config = tseslint.config(
   },
 
   {
-    files: ['packages/cli/**/*', 'scripts/**/*', '.github/**/*', 'config/**/*'],
+    files: ['packages/cli/**/*', 'packages/mcp-server/**/*', 'scripts/**/*', '.github/**/*', 'config/**/*'],
     languageOptions: {
       globals: {
         ...globals.node,
diff --git a/packages/main/src/components/SplitterLayout/test/SplitterLayout.spec.tsx b/packages/main/src/components/SplitterLayout/test/SplitterLayout.spec.tsx
index b8a29e124b6..832eea03164 100644
--- a/packages/main/src/components/SplitterLayout/test/SplitterLayout.spec.tsx
+++ b/packages/main/src/components/SplitterLayout/test/SplitterLayout.spec.tsx
@@ -1,5 +1,5 @@
-import { expect, test } from '../../../../../../playwright/fixtures/main-fixtures.js';
 import type { Page } from '@playwright/test';
+import { expect, test } from '../../../../../../playwright/fixtures/main-fixtures.js';
 import {
   SplitterMoveResetTestComp,
   SplitterMultipleElementsTestComp,
diff --git a/packages/mcp-server/.gitignore b/packages/mcp-server/.gitignore
new file mode 100644
index 00000000000..0b18de06e5e
--- /dev/null
+++ b/packages/mcp-server/.gitignore
@@ -0,0 +1,9 @@
+# Build output
+dist/
+
+# Bundled documentation (copied from monorepo at build time)
+docs/
+
+# TypeScript build info
+tsconfig.tsbuildinfo
+tsconfig.build.tsbuildinfo
diff --git a/packages/mcp-server/README.md b/packages/mcp-server/README.md
new file mode 100644
index 00000000000..f217724b660
--- /dev/null
+++ b/packages/mcp-server/README.md
@@ -0,0 +1,167 @@
+# UI5 Web Components for React MCP Server
+
+Model Context Protocol (MCP) server providing development assistance and API documentation for developers using `@ui5/webcomponents-react`.
+
+## What is this?
+
+This MCP server gives AI assistants direct access to UI5 Web Components for React documentation, component APIs, and utility information. It helps developers get accurate, up-to-date information about the library without leaving their IDE.
+
+## Features
+
+### Available Tools
+
+1. **`list_components`** - Browse all available components
+   - Filter by category (Data Display, Layouts & Floorplans, Inputs, Modals & Popovers, User Feedback, Charts, AI Components, Web Components)
+   - Filter by package (`@ui5/webcomponents-react`, `@ui5/webcomponents-react-charts`, `@ui5/webcomponents-ai-react`)
+   - Shows component types (React vs WebComponent)
+   - Includes detailed descriptions extracted from JSDoc
+   - Provides import examples for each component
+
+2. **`get_component_api`** - Full component API documentation
+   - Props with TypeScript types, descriptions, and defaults
+   - Ref methods and return types
+   - Case-insensitive component name matching
+
+3. **`get_documentation`** - Comprehensive documentation sections
+   - Getting Started guide
+   - Migration guide (v1 → v2)
+   - Knowledge Base (styling, i18n, SSR, testing, slots, FAQ)
+   - Cypress Testing guides
+   - Patterns and best practices
+   - Optionally fetches full markdown content from GitHub
+
+## Setup
+
+### Prerequisites
+
+- Node.js 20.17+ or 22.9+
+
+### Configuration
+
+Add the server to your MCP client configuration. No installation needed — `npx` downloads it on demand.
+
+#### Claude Desktop / Generic MCP Client
+
+```json
+{
+  "mcpServers": {
+    "@ui5/webcomponents-react-mcp": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@ui5/webcomponents-react-mcp"]
+    }
+  }
+}
+```
+
+#### Windows (Non-WSL)
+
+```json
+{
+  "mcpServers": {
+    "@ui5/webcomponents-react-mcp": {
+      "type": "stdio",
+      "command": "cmd",
+      "args": ["/c", "npx -y @ui5/webcomponents-react-mcp"]
+    }
+  }
+}
+```
+
+#### VS Code
+
+```bash
+code --add-mcp '{"name":"@ui5/webcomponents-react-mcp","type":"stdio","command":"npx","args":["-y","@ui5/webcomponents-react-mcp"]}'
+```
+
+#### Claude Code
+
+```bash
+claude mcp add --transport stdio --scope user ui5-wcr-mcp -- npx -y @ui5/webcomponents-react-mcp
+```
+
+#### Codex
+
+```bash
+codex mcp add --transport stdio ui5-wcr-mcp -- npx -y @ui5/webcomponents-react-mcp
+```
+
+## Usage
+
+Once configured, your AI assistant will have access to the tools. You can ask questions like:
+
+**Documentation:**
+
+- "Show me the FAQ"
+- "How do I get started with UI5 Web Components for React?"
+- "How do I style components?"
+- "How do I migrate from v1 to v2?"
+
+**Components:**
+
+- "List all available components"
+- "Show me chart components"
+- "What layout components are available?"
+- "Show me the API for AnalyticalTable"
+- "How do I use the Button component?"
+
+## Development
+
+### Scripts
+
+```bash
+npm run build             # Build TypeScript + copy JSON assets
+npm run dev               # Build and run locally
+npm run inspector         # Debug with MCP Inspector (opens web UI)
+npm run type-check        # Type-check without emitting
+npm run extract:descriptions  # Regenerate component metadata from monorepo sources
+npm run update            # Extract descriptions + rebuild
+```
+
+### Updating Component Metadata
+
+When `@ui5/webcomponents-react` packages are updated, regenerate the component metadata:
+
+```bash
+npm run update
+```
+
+This will:
+
+1. Extract component descriptions from JSDoc and TypeScript definitions
+2. Update component API metadata (`component-apis.json`)
+3. Update component descriptions (`descriptions.json`)
+4. Rebuild the MCP server
+
+### Debug Logging
+
+Enable debug logging by setting the `DEBUG` environment variable:
+
+```bash
+DEBUG=true npm run dev
+```
+
+### Testing with MCP Inspector
+
+The MCP Inspector provides a web-based UI for testing your MCP server:
+
+```bash
+npm run inspector
+```
+
+## How It Works
+
+This MCP server uses pre-processed metadata extracted from the `@ui5/webcomponents-react` packages. Component metadata is bundled with the server, while documentation content can optionally be fetched from GitHub at runtime.
+
+### Data Sources
+
+**`list_components` & `get_component_api`**
+
+- Extracted using `react-docgen-typescript` from TypeScript definitions in the monorepo
+- Component descriptions, categories, and package info → `descriptions.json`
+- Full component APIs including props, methods, types, defaults → `component-apis.json`
+
+**`get_documentation`**
+
+- Metadata pre-stored in `documentation_sections.json`
+- Actual content fetched at runtime via GitHub raw URLs when `fetchContent: true`
diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
new file mode 100644
index 00000000000..34bb83986a5
--- /dev/null
+++ b/packages/mcp-server/package.json
@@ -0,0 +1,75 @@
+{
+  "name": "@ui5/webcomponents-react-mcp",
+  "description": "Model Context Protocol server for UI5 Web Components for React - Developer documentation and API assistance",
+  "author": "SAP SE (https://www.sap.com)",
+  "license": "Apache-2.0",
+  "version": "2.20.0",
+  "type": "module",
+  "mcpName": "io.github.UI5/webcomponents-react-mcp-server",
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "ui5-wcr-mcp": "./dist/index.js"
+  },
+  "engines": {
+    "node": "^20.17.0 || >=22.9.0",
+    "npm": ">= 8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/UI5/webcomponents-react",
+    "directory": "packages/mcp-server"
+  },
+  "scripts": {
+    "extract:descriptions": "tsx scripts/extract_component_descriptions.ts",
+    "bundle:docs": "tsx scripts/bundle_docs.ts",
+    "build": "tsc --build tsconfig.build.json && cp src/tools/list_components/descriptions.json dist/tools/list_components/descriptions.json && cp src/tools/get_component_api/component-apis.json dist/tools/get_component_api/component-apis.json && cp src/tools/get_documentation/documentation_sections.json dist/tools/get_documentation/documentation_sections.json && node -e \"require('fs').chmodSync('dist/index.js', '755')\"",
+    "fetch:skills": "tsx scripts/fetch_upstream_skills.ts",
+    "update": "npm run fetch:skills && npm run extract:descriptions && npm run bundle:docs && npm run build",
+    "clean": "rimraf dist tsconfig.tsbuildinfo tsconfig.build.tsbuildinfo",
+    "dev": "npm run build && ./dist/index.js",
+    "inspector": "npx @modelcontextprotocol/inspector node ./dist/index.js",
+    "type-check": "tsc --noEmit",
+    "test": "npm run build && ava",
+    "test:watch": "ava --watch"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "docs",
+    "resources",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "keywords": [
+    "ui5",
+    "webcomponents",
+    "react",
+    "mcp",
+    "sap",
+    "fiori"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "@ui5/webcomponents": "2.19.2",
+    "@ui5/webcomponents-base": "2.19.2",
+    "@ui5/webcomponents-react": "workspace:~",
+    "ava": "^6.4.1",
+    "glob": "^12.0.0",
+    "react-docgen-typescript": "^2.4.0",
+    "tsx": "^4.20.6"
+  }
+}
diff --git a/packages/mcp-server/resources/llms.txt b/packages/mcp-server/resources/llms.txt
new file mode 100644
index 00000000000..01a132e8585
--- /dev/null
+++ b/packages/mcp-server/resources/llms.txt
@@ -0,0 +1,61 @@
+# UI5 Web Components for React
+
+> React component library wrapping SAP's UI5 Web Components for building enterprise-grade, Fiori-compliant applications.
+
+This MCP server provides documentation and API assistance for consumers of UI5 Web Components for React packages.
+
+## Scope
+
+This server covers these public packages:
+- `@ui5/webcomponents-react` — React wrappers for UI5 Web Components + custom React components
+- `@ui5/webcomponents-react-charts` — Chart components built on recharts
+- `@ui5/webcomponents-ai-react` — AI-enhanced component wrappers
+- `@ui5/webcomponents-react-base` — Public utilities: Device API, ThemingParameters, hooks
+
+This server does NOT cover:
+- Build tooling, bundler configuration, or deployment
+- `@ui5/webcomponents-react-compat` (deprecated/legacy components)
+- `@ui5/webcomponents-react-cli` (internal tooling)
+- Internal/private APIs of `@ui5/webcomponents-react-base`
+- The UI5 Web Components themselves (only their React wrappers)
+
+## Available MCP Tools
+
+- `list_components`: Browse all 203 available components by category or package. Use this first to discover component names.
+- `get_component_api`: Get detailed props, methods, and type information for any component. Use after list_components.
+- `get_documentation`: Read documentation guides, search across topics, and retrieve full content with line-range support.
+- `get_public_utils`: Get documentation for Device API, ThemingParameters, useI18nBundle, useViewportRange, and withWebComponent from @ui5/webcomponents-react-base.
+
+## Documentation
+
+- [Getting Started](docs--Welcome.mdx): Installation, peer dependencies, ThemeProvider configuration, React 18+ setup, wrapper components concept
+- [Project Templates & Examples](docs--ProjectTemplates.mdx): Vite, CRA, Next.js, and CodeSandbox project templates with pre-configured setups
+
+### Knowledge Base
+
+- [Bring Your Own Web Components](docs--knowledge-base--BringYourOwnWebComponents.mdx): Wrapping custom web components with CLI tools and code-mods
+- [Common CSS](docs--knowledge-base--CommonCSS.mdx): CSS Modules, design tokens, theming parameters, CSS variables
+- [FAQ](docs--knowledge-base--FAQ.mdx): Frequently asked questions, troubleshooting, best practices
+- [Handling Slots](docs--knowledge-base--CustomComponentsSlots.mdx): Web Components slot mechanism, named slots, content projection
+- [IDs via Dataset](docs--knowledge-base--ChangeEvents.mdx): HTML data-* attributes, dataset API, DOM element identification
+- [Internationalization](docs--knowledge-base--Internationalization.mdx): Multi-language support, locale configuration, RTL, number/date formatting
+- [Public Utils](docs--knowledge-base--Public-Utils.mdx): Utility functions from @ui5/webcomponents-react-base, ThemingParameters
+- [Server Side Rendering](docs--knowledge-base--ServerSideRendering.mdx): SSR with Next.js, shadow DOM challenges, hydration strategies
+- [Styling](docs--knowledge-base--Styling.mdx): CSS variables, shadow parts (::part), custom states (:state), ThemingParameters, CSS bundles
+- [Accessibility](upstream--accessibility.mdx): Accessibility APIs, proxy attributes, label-input relationships, screen reader support
+
+### Patterns
+
+- [Architecture Patterns](docs--Patterns.mdx): Common use cases, component interactions, composition strategies
+- [SelectionAssistant (Experimental)](patterns--selection-assistant--SelectionAssistant.mdx): Advanced multi-selection with filtering and search
+
+## Key Concepts
+
+- Web components emit CustomEvents with data in `e.detail` (not `e.value`)
+- For controlled components, call `e.preventDefault()` to prevent internal state updates
+- Slot props require forwarding the `slot` prop to the root element
+- Shadow DOM styling uses `::part()` pseudo-element and CSS variables (`--sapBackgroundColor`, etc.)
+- Components support both React 18 and React 19+
+- Use subpath imports for @ui5/webcomponents-react-base (e.g., `@ui5/webcomponents-react-base/hooks`)
+- Web components use proxy attributes (`accessibleName`, `accessibleNameRef`) instead of standard `aria-*` for shadow DOM compatibility
+- When creating a new application, prefer official project templates (Next.js, Vite) over scaffolding from scratch. Use get_documentation({ section: "Project Templates & Examples", fetchContent: true }) to find available templates. Only fall back to generic framework setup if no template matches the user's framework.
diff --git a/packages/mcp-server/scripts/bundle_docs.ts b/packages/mcp-server/scripts/bundle_docs.ts
new file mode 100644
index 00000000000..030bddd7874
--- /dev/null
+++ b/packages/mcp-server/scripts/bundle_docs.ts
@@ -0,0 +1,172 @@
+#!/usr/bin/env tsx
+
+/**
+ * Bundle documentation files from the monorepo into the MCP server package.
+ * Copies MDX/MD/TS files referenced in documentation_sections.json to docs/.
+ *
+ * For entries with a companion `data_source` (JSON), generates LLM-friendly
+ * markdown instead of copying raw MDX (which may contain JSX components).
+ *
+ * Usage:
+ *   npm run bundle:docs
+ *
+ * TODO: Re-evaluate adding "UXC Integration" to documentation_sections.json
+ * once the UXC docs page has bundleable content (currently metadata-only,
+ * removed because fetchContent would return "not available locally").
+ */
+
+import type { DocumentationData } from '../src/types/index.js';
+
+import { readFileSync, writeFileSync, mkdirSync, cpSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const MONOREPO_ROOT = join(__dirname, '../../..');
+const DOCS_DIR = join(__dirname, '../docs');
+const SECTIONS_PATH = join(__dirname, '../src/tools/get_documentation/documentation_sections.json');
+
+const REPO_BASE = 'https://github.com/UI5/webcomponents-react/tree/main/';
+
+/**
+ * Generate a flat, safe filename for the docs/ directory.
+ * e.g., "docs/knowledge-base/FAQ.mdx" → "docs--knowledge-base--FAQ.mdx"
+ */
+function toLocalFilename(relativePath: string): string {
+  return relativePath.replace(/\//g, '--');
+}
+
+interface ProjectTemplate {
+  name: string;
+  variant?: string;
+  framework: string;
+  type: 'template' | 'example';
+  path: string;
+  typescript?: boolean;
+  stackBlitz?: string;
+  features?: string[];
+}
+
+/**
+ * Generate LLM-friendly markdown from project-templates.json
+ */
+function generateTemplateMarkdown(dataSourcePath: string): string {
+  const fullPath = join(MONOREPO_ROOT, dataSourcePath);
+  if (!existsSync(fullPath)) {
+    console.warn(`  Data source not found: ${dataSourcePath}`);
+    return '';
+  }
+
+  const templates: ProjectTemplate[] = JSON.parse(readFileSync(fullPath, 'utf-8'));
+  const templateEntries = templates.filter((t) => t.type === 'template');
+  const exampleEntries = templates.filter((t) => t.type === 'example');
+
+  let md = '# Project Templates & Examples\n\n';
+  md += 'Official project templates and examples for UI5 Web Components for React.\n';
+  md += 'When creating a new application, use these templates instead of scaffolding from scratch.\n\n';
+
+  md += '## Templates (use for new projects)\n\n';
+  for (const t of templateEntries) {
+    const label = t.variant ? `${t.name} (${t.variant})` : t.name;
+    md += `### ${label}\n`;
+    md += `- **GitHub**: ${REPO_BASE}${t.path}\n`;
+    if (t.stackBlitz) {
+      md += `- **StackBlitz**: ${t.stackBlitz}\n`;
+    }
+    if (t.typescript) {
+      md += `- **Language**: TypeScript\n`;
+    }
+    md += '\n';
+  }
+
+  md += '## Examples (use as reference)\n\n';
+  for (const t of exampleEntries) {
+    const label = t.variant ? `${t.name} (${t.variant})` : t.name;
+    md += `### ${label}\n`;
+    md += `- **GitHub**: ${REPO_BASE}${t.path}\n`;
+    if (t.stackBlitz) {
+      md += `- **StackBlitz**: ${t.stackBlitz}\n`;
+    }
+    if (t.typescript) {
+      md += `- **Language**: TypeScript\n`;
+    }
+    if (t.features?.length) {
+      md += `- **Features**:\n`;
+      for (const f of t.features) {
+        md += `  - ${f}\n`;
+      }
+    }
+    md += '\n';
+  }
+
+  return md;
+}
+
+function main() {
+  console.log('Bundling documentation files...\n');
+
+  mkdirSync(DOCS_DIR, { recursive: true });
+
+  const docsData: DocumentationData = JSON.parse(readFileSync(SECTIONS_PATH, 'utf-8'));
+
+  let copied = 0;
+  let generated = 0;
+  let skipped = 0;
+
+  function processEntry(entry: { sourcePath?: string; dataSource?: string; localPath?: string }) {
+    // If a dataSource is provided, generate LLM-friendly markdown from it
+    if (entry.dataSource) {
+      const localFilename = toLocalFilename(entry.dataSource).replace(/\.json$/, '.md');
+      const destPath = join(DOCS_DIR, localFilename);
+      const content = generateTemplateMarkdown(entry.dataSource);
+      if (content) {
+        writeFileSync(destPath, content);
+        entry.localPath = localFilename;
+        generated++;
+        console.log(`  ${entry.dataSource} -> docs/${localFilename} (generated)`);
+      }
+      return;
+    }
+
+    if (!entry.sourcePath) return;
+
+    const sourcePath = join(MONOREPO_ROOT, entry.sourcePath);
+    const localFilename = toLocalFilename(entry.sourcePath);
+    const destPath = join(DOCS_DIR, localFilename);
+
+    try {
+      cpSync(sourcePath, destPath);
+      entry.localPath = localFilename;
+      copied++;
+      console.log(`  ${entry.sourcePath} -> docs/${localFilename}`);
+    } catch (error) {
+      console.warn(`  Failed to copy ${entry.sourcePath}: ${(error as Error).message}`);
+      skipped++;
+    }
+  }
+
+  for (const section of docsData.sections) {
+    processEntry(section);
+
+    if (section.subsections) {
+      for (const subsection of section.subsections) {
+        processEntry(subsection);
+      }
+    }
+  }
+
+  writeFileSync(SECTIONS_PATH, JSON.stringify(docsData, null, 2) + '\n');
+
+  console.log(`\nBundled ${copied} documentation files to docs/`);
+  if (generated > 0) {
+    console.log(`Generated ${generated} files from data sources`);
+  }
+  if (skipped > 0) {
+    console.log(`Skipped ${skipped} files`);
+  }
+  console.log(`Updated ${SECTIONS_PATH}`);
+}
+
+main();
diff --git a/packages/mcp-server/scripts/extract_component_descriptions.ts b/packages/mcp-server/scripts/extract_component_descriptions.ts
new file mode 100644
index 00000000000..af6ebcf8613
--- /dev/null
+++ b/packages/mcp-server/scripts/extract_component_descriptions.ts
@@ -0,0 +1,182 @@
+#!/usr/bin/env tsx
+
+/**
+ * Extract component descriptions and API data from the monorepo.
+ * Reads component source files, parses JSDoc/props via react-docgen-typescript,
+ * and enriches web component data with Custom Elements Manifest (CEM) info.
+ *
+ * Outputs:
+ *   - src/tools/list_components/descriptions.json
+ *   - src/tools/get_component_api/component-apis.json
+ *
+ * Usage:
+ *   npm run extract:descriptions
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { glob } from 'glob';
+import type { DescriptionsStore, ApiDataStore, ComponentDescription, ComponentApiData } from '../src/types/index.js';
+import {
+  REACT_COMPONENT_CATEGORIES,
+  WEB_COMPONENT_CATEGORIES,
+  CHART_CATEGORIES,
+  AI_CATEGORIES,
+} from '../src/utils/categories.js';
+import { findComponentCategory } from './utils/text.js';
+import { extractDescription, extractFullComponentApi } from './utils/docgen.js';
+import { loadCemData, enrichWithCem } from './utils/cem.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const UI5_WCR_PATH = join(__dirname, '../../..');
+
+async function main() {
+  console.log('Extracting component descriptions and API data...\n');
+
+  const descriptions: DescriptionsStore = { components: {}, webComponents: {}, charts: {}, ai: {} };
+  const componentApis: ApiDataStore = { components: {}, webComponents: {}, charts: {}, ai: {} };
+  const missingComponents: string[] = [];
+
+  // --- React components ---
+  const componentFiles = (
+    await glob('packages/main/src/components/*/index.{ts,tsx}', { cwd: UI5_WCR_PATH, absolute: true })
+  ).sort();
+
+  console.log(`Found ${componentFiles.length} React components`);
+  for (const file of componentFiles) {
+    const name = file.split('/').slice(-2, -1)[0];
+    if (!findComponentCategory(name, REACT_COMPONENT_CATEGORIES)) {
+      missingComponents.push(name);
+    }
+    const desc = extractDescription(file);
+    if (desc) {
+      descriptions.components[name] = { description: desc, package: '@ui5/webcomponents-react' };
+    }
+    const api = extractFullComponentApi(file, '@ui5/webcomponents-react', name, __dirname);
+    if (api) {
+      componentApis.components[name] = api;
+    }
+  }
+
+  // --- Web Components ---
+  console.log('Loading custom-elements manifests...');
+  const { lookup: cemLookup, wcDescriptions, aiDescriptions } = loadCemData(UI5_WCR_PATH);
+
+  const wcFiles = (
+    await glob('packages/main/src/webComponents/*/index.tsx', { cwd: UI5_WCR_PATH, absolute: true })
+  ).sort();
+
+  console.log(`Found ${wcFiles.length} Web Components`);
+  for (const file of wcFiles) {
+    const name = file.split('/').slice(-2, -1)[0];
+    if (!findComponentCategory(name, WEB_COMPONENT_CATEGORIES)) {
+      missingComponents.push(name);
+    }
+    descriptions.webComponents[name] = {
+      description: wcDescriptions[name] || 'UI5 Web Component wrapper',
+      package: '@ui5/webcomponents-react',
+    };
+    const api = extractFullComponentApi(file, '@ui5/webcomponents-react', name, __dirname);
+    if (api) {
+      const cemEntry = cemLookup.get(name);
+      if (cemEntry) enrichWithCem(api, cemEntry.decl);
+      componentApis.webComponents[name] = api;
+    }
+  }
+
+  // --- Charts ---
+  const chartFiles = (
+    await glob('packages/charts/src/components/*/index.tsx', { cwd: UI5_WCR_PATH, absolute: true })
+  ).sort();
+
+  console.log(`Found ${chartFiles.length} Chart components`);
+  for (const file of chartFiles) {
+    const name = file.split('/').slice(-2, -1)[0];
+    if (!findComponentCategory(name, CHART_CATEGORIES)) {
+      missingComponents.push(name);
+    }
+    const desc = extractDescription(file);
+    if (desc) {
+      descriptions.charts[name] = { description: desc, package: '@ui5/webcomponents-react-charts' };
+    }
+    const api = extractFullComponentApi(file, '@ui5/webcomponents-react-charts', name, __dirname);
+    if (api) {
+      componentApis.charts[name] = api;
+    }
+  }
+
+  // --- AI components ---
+  const aiFiles = (await glob('packages/ai/src/components/*/index.tsx', { cwd: UI5_WCR_PATH, absolute: true })).sort();
+
+  console.log(`Found ${aiFiles.length} AI components`);
+  for (const file of aiFiles) {
+    const name = file.split('/').slice(-2, -1)[0];
+    if (!findComponentCategory(name, AI_CATEGORIES)) {
+      missingComponents.push(name);
+    }
+    descriptions.ai[name] = {
+      description: aiDescriptions[name] || extractDescription(file) || 'AI-enhanced component',
+      package: '@ui5/webcomponents-ai-react',
+    };
+    const api = extractFullComponentApi(file, '@ui5/webcomponents-ai-react', name, __dirname);
+    if (api) {
+      const cemEntry = cemLookup.get(name);
+      if (cemEntry) enrichWithCem(api, cemEntry.decl);
+      componentApis.ai[name] = api;
+    }
+  }
+
+  // --- Metadata ---
+  try {
+    const wcrPkg = JSON.parse(readFileSync(join(UI5_WCR_PATH, 'packages/main/package.json'), 'utf-8'));
+    const metadata = {
+      version: wcrPkg.version,
+      extractedAt: new Date().toISOString(),
+      componentsCount: Object.keys(descriptions.components).length,
+      webComponentsCount: Object.keys(descriptions.webComponents).length,
+      chartsCount: Object.keys(descriptions.charts).length,
+      aiCount: Object.keys(descriptions.ai).length,
+    };
+    descriptions.metadata = metadata;
+    componentApis.metadata = metadata;
+  } catch (error) {
+    console.warn('Could not extract version info:', (error as Error).message);
+  }
+
+  // --- Write outputs ---
+  const descPath = join(__dirname, '../src/tools/list_components/descriptions.json');
+  writeFileSync(descPath, JSON.stringify(descriptions, null, 2));
+
+  const apiPath = join(__dirname, '../src/tools/get_component_api/component-apis.json');
+  writeFileSync(apiPath, JSON.stringify(componentApis, null, 2));
+
+  // --- Summary ---
+  console.log(`\nExtracted descriptions:`);
+  console.log(`- React components: ${Object.keys(descriptions.components).length}`);
+  console.log(`- Web Components: ${Object.keys(descriptions.webComponents).length}`);
+  console.log(`- Charts: ${Object.keys(descriptions.charts).length}`);
+  console.log(`- AI: ${Object.keys(descriptions.ai).length}`);
+
+  console.log(`\nExtracted API data:`);
+  console.log(`- React components: ${Object.keys(componentApis.components).length}`);
+  console.log(`- Web Components: ${Object.keys(componentApis.webComponents).length}`);
+  console.log(`- Charts: ${Object.keys(componentApis.charts).length}`);
+  console.log(`- AI: ${Object.keys(componentApis.ai).length}`);
+
+  if (descriptions.metadata) {
+    console.log(`\nVersion: ${descriptions.metadata.version}`);
+  }
+  console.log(`CEM lookup: ${cemLookup.size} web component declarations loaded`);
+  console.log(`\nSaved descriptions to: ${descPath}`);
+  console.log(`Saved API data to: ${apiPath}`);
+
+  if (missingComponents.length > 0) {
+    console.error(`\nERROR: The following components are missing category definitions:`);
+    missingComponents.forEach((name) => console.error(`   - ${name}`));
+  }
+}
+
+main().catch(console.error);
diff --git a/packages/mcp-server/scripts/fetch_upstream_skills.ts b/packages/mcp-server/scripts/fetch_upstream_skills.ts
new file mode 100644
index 00000000000..7af01edc318
--- /dev/null
+++ b/packages/mcp-server/scripts/fetch_upstream_skills.ts
@@ -0,0 +1,79 @@
+#!/usr/bin/env tsx
+
+/**
+ * Fetch upstream skill documents from the UI5 Web Components repo.
+ * Strips YAML frontmatter and adds a header note for React context.
+ *
+ * The consuming LLM agent resolves web component tag names and
+ * kebab-case attributes to React equivalents via `get_component_api`.
+ *
+ * Usage:
+ *   npm run fetch:skills
+ */
+
+import { writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const DOCS_DIR = join(__dirname, '../docs');
+
+interface UpstreamSkill {
+  url: string;
+  outputFile: string;
+}
+
+const SKILLS: UpstreamSkill[] = [
+  {
+    url: 'https://raw.githubusercontent.com/SAP/ui5-webcomponents/main/skills/accessibility/SKILL.md',
+    outputFile: 'upstream--accessibility.mdx',
+  },
+];
+
+/** Strip YAML frontmatter (content between --- markers at start of file) */
+function stripFrontmatter(content: string): string {
+  const match = content.match(/^---\n[\s\S]*?\n---\n?/);
+  return match ? content.slice(match[0].length) : content;
+}
+
+const HEADER = `> This document is adapted from the [UI5 Web Components Accessibility Skill](https://github.com/SAP/ui5-webcomponents/blob/main/skills/accessibility/SKILL.md).
+> Code examples use HTML web component syntax (\`<ui5-button>\`, \`accessible-name\`).
+> Use \`get_component_api\` to look up the corresponding React component names and camelCase props.
+
+`;
+
+async function fetchAndAdapt(skill: UpstreamSkill): Promise<void> {
+  console.log(`Fetching: ${skill.url}`);
+
+  const response = await fetch(skill.url);
+  if (!response.ok) {
+    throw new Error(`ERROR: Failed to fetch upstream skill from ${skill.url}. HTTP status: ${response.status}`);
+  }
+
+  let content = await response.text();
+  content = stripFrontmatter(content);
+  content = HEADER + content;
+
+  const outputPath = join(DOCS_DIR, skill.outputFile);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, content);
+
+  console.log(`  → ${outputPath}`);
+}
+
+async function main() {
+  console.log('Fetching upstream skills...\n');
+
+  for (const skill of SKILLS) {
+    await fetchAndAdapt(skill);
+  }
+
+  console.log('\nDone.');
+}
+
+main().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});
diff --git a/packages/mcp-server/scripts/utils/cem.ts b/packages/mcp-server/scripts/utils/cem.ts
new file mode 100644
index 00000000000..694ecd1615f
--- /dev/null
+++ b/packages/mcp-server/scripts/utils/cem.ts
@@ -0,0 +1,136 @@
+/**
+ * Custom Elements Manifest (CEM) loading and enrichment.
+ * Reads CEM files from node_modules and builds lookup maps for
+ * enriching component API data with event details and CSS parts.
+ *
+ * TODO: The CLI package has similar utilities (cem-reader.ts, formatters.ts)
+ * but doesn't export them. If the CLI adds subpath exports, consider
+ * reusing getCEM() and snakeCaseToCamelCase() from there instead.
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import type { CemManifest, CemDeclaration, ComponentApiData } from '../../src/types/index.js';
+import { toPascalCase } from './text.js';
+
+/**
+ * Convert CEM event name (kebab-case) to React event handler prop name.
+ * e.g., "before-close" → "onBeforeClose", "click" → "onClick"
+ */
+export function cemEventToReactProp(eventName: string): string {
+  const camel = eventName.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase());
+  return 'on' + camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+/**
+ * Load all CEM files and build a lookup map from component name → CEM declaration.
+ * Also extracts short descriptions for the descriptions.json output.
+ */
+export function loadCemData(monorepoRoot: string): {
+  lookup: Map<string, { decl: CemDeclaration; isAi: boolean }>;
+  wcDescriptions: Record<string, string>;
+  aiDescriptions: Record<string, string>;
+} {
+  const lookup = new Map<string, { decl: CemDeclaration; isAi: boolean }>();
+  const wcDescriptions: Record<string, string> = {};
+  const aiDescriptions: Record<string, string> = {};
+
+  const manifestPaths = [
+    { path: 'node_modules/@ui5/webcomponents/dist/custom-elements-internal.json', isAi: false },
+    { path: 'node_modules/@ui5/webcomponents-fiori/dist/custom-elements-internal.json', isAi: false },
+    { path: 'node_modules/@ui5/webcomponents-ai/dist/custom-elements-internal.json', isAi: true },
+  ];
+
+  for (const { path: manifestPath, isAi } of manifestPaths) {
+    try {
+      const fullPath = join(monorepoRoot, manifestPath);
+      const manifest: CemManifest = JSON.parse(readFileSync(fullPath, 'utf-8'));
+
+      for (const module of manifest.modules || []) {
+        for (const decl of module.declarations || []) {
+          if (!decl.name) continue;
+
+          if (decl.tagName) {
+            lookup.set(decl.name, { decl, isAi });
+          }
+
+          if (decl.description) {
+            let desc = decl.description
+              .replace(/###\s+Overview\s*/i, '')
+              .split('\n\n')[0]
+              .replace(/\n/g, ' ')
+              .trim();
+
+            // Replace ui5-component-name with PascalCase
+            desc = desc.replace(/`ui5-(?:ai-)?[\w-]+`/g, (match) => {
+              const componentName = match.slice(1, -1);
+              return `\`${toPascalCase(componentName)}\``;
+            });
+            desc = desc.replace(/ui5-(?:ai-)?([\w-]+)/g, (match) => {
+              return toPascalCase(match);
+            });
+
+            // Get first sentence
+            const sentenceEnd = desc.match(/\.\s/);
+            const cleanDesc =
+              sentenceEnd && sentenceEnd.index! < 300
+                ? desc.substring(0, sentenceEnd.index! + 1)
+                : desc.substring(0, 200) + '...';
+
+            if (isAi) {
+              aiDescriptions[decl.name] = cleanDesc;
+            } else {
+              wcDescriptions[decl.name] = cleanDesc;
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`Could not load ${manifestPath}:`, (error as Error).message);
+    }
+  }
+
+  return { lookup, wcDescriptions, aiDescriptions };
+}
+
+/**
+ * Enrich component API data with CEM information:
+ * - eventDetail (params, cancelable, bubbles) on event handler props
+ * - cssParts on component root
+ */
+export function enrichWithCem(apiData: ComponentApiData, cemDecl: CemDeclaration): void {
+  if (cemDecl.events) {
+    for (const event of cemDecl.events) {
+      if (event._ui5privacy && event._ui5privacy !== 'public') continue;
+
+      const reactPropName = cemEventToReactProp(event.name);
+      const prop = apiData.props[reactPropName];
+      if (!prop) continue;
+
+      const hasParams = event._ui5parameters && event._ui5parameters.length > 0;
+      const cancelable = event._ui5Cancelable ?? false;
+      const bubbles = event._ui5Bubbles ?? false;
+
+      if (hasParams || cancelable || bubbles) {
+        prop.eventDetail = {
+          params: (event._ui5parameters || [])
+            .filter((p) => !p._ui5privacy || p._ui5privacy === 'public')
+            .map((p) => ({
+              name: p.name,
+              type: p.type.text,
+              description: p.description,
+            })),
+          cancelable,
+          bubbles,
+        };
+      }
+    }
+  }
+
+  if (cemDecl.cssParts && cemDecl.cssParts.length > 0) {
+    apiData.cssParts = cemDecl.cssParts.map((p) => ({
+      name: p.name,
+      description: p.description,
+    }));
+  }
+}
diff --git a/packages/mcp-server/scripts/utils/docgen.ts b/packages/mcp-server/scripts/utils/docgen.ts
new file mode 100644
index 00000000000..8309c48ae59
--- /dev/null
+++ b/packages/mcp-server/scripts/utils/docgen.ts
@@ -0,0 +1,275 @@
+/**
+ * React-docgen-typescript extraction helpers.
+ * Parses component files for props, methods, and type information.
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import * as docgen from 'react-docgen-typescript';
+import type { PropItem } from 'react-docgen-typescript';
+import type { TypeInfo, CleanedProp, MethodInfo, MethodParam, ComponentApiData } from '../../src/types/index.js';
+import { cleanJSDocDescription } from './text.js';
+
+const parser = docgen.withDefaultConfig({
+  savePropValueAsString: true,
+  shouldExtractLiteralValuesFromEnum: true,
+  shouldRemoveUndefinedFromOptional: true,
+});
+
+/**
+ * Clean up type information to remove redundant fields.
+ * Strips fullComment, tags from enum values to reduce file size.
+ */
+export function cleanTypeInfo(type: PropItem['type']): TypeInfo {
+  if (!type) return { name: 'unknown' };
+
+  const cleaned: TypeInfo = { name: type.name };
+
+  if (type.raw) {
+    cleaned.raw = type.raw;
+  }
+
+  if (type.value && Array.isArray(type.value)) {
+    cleaned.value = type.value.map((val: any) => {
+      if (typeof val === 'object' && val !== null) {
+        const cleanedVal: any = { value: val.value };
+        if (val.description) {
+          cleanedVal.description = val.description;
+        }
+        return cleanedVal;
+      }
+      return val;
+    });
+  } else if (type.value) {
+    cleaned.value = type.value;
+  }
+
+  return cleaned;
+}
+
+// todo: there are custom events that have the same name as commonprops, do not just filter them out
+/**
+ * Check if a prop comes from CommonProps/HTMLAttributes.
+ * These are filtered out to reduce file size.
+ */
+export function isCommonProp(propName: string, propData: PropItem): boolean {
+  const parentName = propData.parent?.name || '';
+  if (
+    parentName.includes('HTMLAttributes') ||
+    parentName.includes('CommonProps') ||
+    parentName.includes('DOMAttributes') ||
+    parentName.includes('AriaAttributes')
+  ) {
+    return true;
+  }
+
+  const htmlAttributes = [
+    'className',
+    'style',
+    'id',
+    'title',
+    'slot',
+    'ref',
+    'onClick',
+    'onDoubleClick',
+    'onMouseDown',
+    'onMouseUp',
+    'onMouseEnter',
+    'onMouseLeave',
+    'onMouseMove',
+    'onMouseOver',
+    'onMouseOut',
+    'onKeyDown',
+    'onKeyUp',
+    'onKeyPress',
+    'onFocus',
+    'onBlur',
+    'onChange',
+    'onInput',
+    'onSubmit',
+    'onContextMenu',
+    'onDrag',
+    'onDragEnd',
+    'onDragEnter',
+    'onDragExit',
+    'onDragLeave',
+    'onDragOver',
+    'onDragStart',
+    'onDrop',
+  ];
+
+  if (htmlAttributes.includes(propName)) {
+    const desc = propData.description || '';
+    if (desc && !desc.includes('HTMLAttributes') && !desc.includes('DOMAttributes')) {
+      return false;
+    }
+    return true;
+  }
+
+  if (propName.startsWith('aria-') || propName.startsWith('data-')) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Extract methods from DomRef interface in .d.ts file.
+ * Parses the DomRef interface to find method signatures.
+ */
+export function extractDomRefMethods(componentName: string, packagePath: string, scriptDir: string): MethodInfo[] {
+  try {
+    const typeDefPath = join(
+      scriptDir,
+      '../node_modules',
+      packagePath,
+      'dist/webComponents',
+      componentName,
+      'index.d.ts',
+    );
+    const content = readFileSync(typeDefPath, 'utf-8');
+
+    const domRefInterfaceName = `${componentName}DomRef`;
+    const interfaceStart = content.indexOf(`interface ${domRefInterfaceName}`);
+    if (interfaceStart === -1) return [];
+
+    const openBrace = content.indexOf('{', interfaceStart);
+    if (openBrace === -1) return [];
+
+    let braceCount = 1;
+    let pos = openBrace + 1;
+    while (pos < content.length && braceCount > 0) {
+      if (content[pos] === '{') braceCount++;
+      if (content[pos] === '}') braceCount--;
+      pos++;
+    }
+    if (braceCount !== 0) return [];
+
+    const interfaceBody = content.substring(openBrace + 1, pos - 1);
+    const methods: MethodInfo[] = [];
+
+    const methodRegex = /\/\*\*([\s\S]*?)\*\/\s*(\w+):\s*(\([^)]*\)\s*=>\s*[^;]+);/g;
+    let methodMatch;
+
+    while ((methodMatch = methodRegex.exec(interfaceBody)) !== null) {
+      const jsdoc = methodMatch[1];
+      const methodName = methodMatch[2];
+      const signature = methodMatch[3];
+
+      const descLines = jsdoc
+        .split('\n')
+        .map((line) => line.replace(/^\s*\*\s?/, '').trim())
+        .filter((line) => line && !line.startsWith('@'));
+      const description = descLines.join(' ');
+
+      const paramsMatch = signature.match(/\(([^)]*)\)/);
+      const params: MethodParam[] = [];
+      if (paramsMatch && paramsMatch[1].trim()) {
+        for (const param of paramsMatch[1].split(',')) {
+          const paramParts = param.trim().split(':');
+          if (paramParts.length >= 2) {
+            params.push({
+              name: paramParts[0].trim(),
+              type: { name: paramParts[1].trim() },
+              description: '',
+            });
+          }
+        }
+      }
+
+      const returnMatch = signature.match(/=>\s*(.+)$/);
+      const returns = returnMatch ? { type: returnMatch[1].trim() } : null;
+
+      methods.push({ name: methodName, description, params, returns });
+    }
+
+    return methods;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Extract JSDoc description from a component file using react-docgen-typescript.
+ */
+export function extractDescription(filePath: string): string | null {
+  try {
+    const componentDocs = parser.parse(filePath);
+    if (componentDocs.length > 0 && componentDocs[0].description) {
+      return cleanJSDocDescription(componentDocs[0].description);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract full component API data using react-docgen-typescript.
+ * Returns complete props, methods, types, and JSDoc metadata.
+ */
+export function extractFullComponentApi(
+  filePath: string,
+  packageName: string,
+  componentName: string,
+  scriptDir: string,
+): ComponentApiData | null {
+  try {
+    const componentDocs = parser.parse(filePath);
+    if (componentDocs.length === 0) return null;
+
+    const doc = componentDocs[0];
+
+    const cleanedProps: Record<string, CleanedProp> = {};
+    if (doc.props) {
+      for (const [propName, propData] of Object.entries(doc.props)) {
+        if (isCommonProp(propName, propData)) continue;
+        if (propName.includes('@') && propName.match(/@\d+/)) continue;
+
+        const prop: CleanedProp = {
+          type: cleanTypeInfo(propData.type),
+          required: propData.required,
+          description: propData.description || '',
+        };
+
+        if (
+          propData.defaultValue !== null &&
+          propData.defaultValue !== undefined &&
+          propData.defaultValue.value !== 'undefined'
+        ) {
+          prop.defaultValue = propData.defaultValue;
+        }
+
+        cleanedProps[propName] = prop;
+      }
+    }
+
+    let cleanedMethods = extractDomRefMethods(componentName, packageName, scriptDir);
+
+    if (cleanedMethods.length === 0 && doc.methods) {
+      cleanedMethods = doc.methods.map((method) => ({
+        name: method.name,
+        description: method.description || '',
+        params: (method.params || []).map((param) => ({
+          name: param.name,
+          description: param.description || '',
+          type: param.type,
+        })),
+        returns: method.returns || null,
+      }));
+    }
+
+    const descriptionWithNote =
+      (doc.description || '') +
+      '\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.';
+
+    return {
+      package: packageName,
+      description: descriptionWithNote,
+      props: cleanedProps,
+      methods: cleanedMethods,
+    };
+  } catch {
+    return null;
+  }
+}
diff --git a/packages/mcp-server/scripts/utils/text.ts b/packages/mcp-server/scripts/utils/text.ts
new file mode 100644
index 00000000000..451b8b474ec
--- /dev/null
+++ b/packages/mcp-server/scripts/utils/text.ts
@@ -0,0 +1,70 @@
+/**
+ * Text cleaning and naming utilities for component extraction.
+ */
+
+/**
+ * Convert ui5-kebab-case component names to PascalCase.
+ * e.g., "ui5-multi-combobox" → "MultiComboBox", "ui5-ai-button" → "Button"
+ */
+export function toPascalCase(kebabStr: string): string {
+  const withoutPrefix = kebabStr.replace(/^ui5-(?:ai-)?/, '');
+  return withoutPrefix
+    .split('-')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+}
+
+/**
+ * Clean up a JSDoc description to a concise first-sentence summary.
+ */
+export function cleanJSDocDescription(description: string): string | null {
+  if (!description) return null;
+
+  const lines = description
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(
+      (line) =>
+        line &&
+        !line.startsWith('@') &&
+        !line.startsWith('__Note:__') &&
+        !line.startsWith('###') &&
+        !line.includes('UI5 Web Component!') &&
+        !line.includes('Repository'),
+    );
+
+  let cleanDescription = '';
+  for (const line of lines) {
+    if (line.startsWith('##') || line.startsWith('*') || line.startsWith('|')) break;
+    if (line) {
+      cleanDescription += (cleanDescription ? ' ' : '') + line;
+    }
+  }
+
+  if (!cleanDescription) return null;
+
+  const sentenceEnd = cleanDescription.match(/\.\s/);
+  if (sentenceEnd && sentenceEnd.index && sentenceEnd.index < 300) {
+    return cleanDescription.substring(0, sentenceEnd.index + 1).trim();
+  } else if (cleanDescription.length > 200) {
+    const truncated = cleanDescription.substring(0, 200);
+    const lastSpace = truncated.lastIndexOf(' ');
+    if (lastSpace > 150) {
+      return truncated.substring(0, lastSpace) + '...';
+    }
+  }
+
+  return cleanDescription;
+}
+
+/**
+ * Find the category for a component in a categories map.
+ */
+export function findComponentCategory(componentName: string, categories: Record<string, string[]>): string | null {
+  for (const [category, components] of Object.entries(categories)) {
+    if (components.includes(componentName)) {
+      return category;
+    }
+  }
+  return null;
+}
diff --git a/packages/mcp-server/server.json b/packages/mcp-server/server.json
new file mode 100644
index 00000000000..bee9ae63d38
--- /dev/null
+++ b/packages/mcp-server/server.json
@@ -0,0 +1,23 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.UI5/webcomponents-react-mcp-server",
+  "description": "MCP server for UI5 Web Components for React",
+  "repository": {
+    "url": "https://github.com/UI5/webcomponents-react",
+    "source": "github",
+    "subfolder": "packages/mcp-server"
+  },
+  "version": "2.20.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "registryBaseUrl": "https://registry.npmjs.org",
+      "identifier": "@ui5/webcomponents-react-mcp",
+      "version": "2.20.0",
+      "transport": {
+        "type": "stdio"
+      },
+      "environmentVariables": []
+    }
+  ]
+}
diff --git a/packages/mcp-server/src/index.ts b/packages/mcp-server/src/index.ts
new file mode 100644
index 00000000000..879801a3346
--- /dev/null
+++ b/packages/mcp-server/src/index.ts
@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * @fileoverview UI5 Web Components for React MCP Server
+ * Provides development assistance and API documentation for developers using @ui5/webcomponents-react
+ */
+
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { logger } from './logger.js';
+import * as tools from './tools/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Read version from package.json
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+
+const server = new McpServer({
+  name: 'ui5-webcomponents-react',
+  version: pkg.version,
+});
+
+// Register all tools
+logger.info('Registering tools...');
+const toolList = Object.values(tools);
+toolList.forEach((tool) => {
+  logger.debug(`Registering tool: ${tool.name}`);
+  server.registerTool(
+    tool.name,
+    {
+      title: tool.title,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      outputSchema: 'outputSchema' in tool ? tool.outputSchema : undefined,
+      annotations: tool.annotations,
+    },
+    tool.handler,
+  );
+});
+
+logger.info(`Registered ${toolList.length} tools`);
+
+// Register llms.txt resource
+const llmsTxtPath = join(__dirname, '..', 'resources', 'llms.txt');
+server.registerResource(
+  'llms-txt',
+  'file:///llms.txt',
+  {
+    description: 'LLM-friendly documentation index for UI5 Web Components for React',
+    mimeType: 'text/plain',
+  },
+  () => ({
+    contents: [
+      {
+        uri: 'file:///llms.txt',
+        mimeType: 'text/plain',
+        text: readFileSync(llmsTxtPath, 'utf-8'),
+      },
+    ],
+  }),
+);
+logger.info('Registered llms.txt resource');
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info('UI5 Web Components for React MCP Server running on stdio');
+}
+
+main().catch((error) => {
+  logger.error('Fatal error in main():', error);
+  process.exit(1);
+});
diff --git a/packages/mcp-server/src/logger.ts b/packages/mcp-server/src/logger.ts
new file mode 100644
index 00000000000..f5ab452b5eb
--- /dev/null
+++ b/packages/mcp-server/src/logger.ts
@@ -0,0 +1,22 @@
+/**
+ * Simple logger for debugging
+ */
+
+const DEBUG = process.env.DEBUG === 'true';
+
+export const logger = {
+  debug: (...args: unknown[]) => {
+    if (DEBUG) {
+      console.error('[DEBUG]', ...args);
+    }
+  },
+  info: (...args: unknown[]) => {
+    console.error('[INFO]', ...args);
+  },
+  warn: (...args: unknown[]) => {
+    console.error('[WARN]', ...args);
+  },
+  error: (...args: unknown[]) => {
+    console.error('[ERROR]', ...args);
+  },
+};
diff --git a/packages/mcp-server/src/tools/get_component_api/component-apis.json b/packages/mcp-server/src/tools/get_component_api/component-apis.json
new file mode 100644
index 00000000000..e95d86f8a6c
--- /dev/null
+++ b/packages/mcp-server/src/tools/get_component_api/component-apis.json
@@ -0,0 +1,34108 @@
+{
+  "components": {
+    "ActionSheet": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ActionSheet` holds a list of buttons from which the user can select to complete an action.\n\nThe children of the action sheet should be `Button` components. Elements in the `ActionSheet` are start-aligned. Actions should be arranged in order of importance, from top to bottom.\n\n### Guidelines\n- Always display text or text and icons for the actions. Do not use icons only.\n- Always provide a Cancel button on mobile phones.\n- Avoid scrolling on action sheets.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text. Will be shown in the header area on phone devices. This prop will be ignored in tablets and desktop browsers.\n\n**Note:** If `header` slot is provided, the `headerText` is ignored."
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header HTML Element. Will be shown in the header area on phone devices. This prop will be ignored in tablets and desktop browsers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--page)."
+        },
+        "children": {
+          "type": {
+            "name": "ReactElement<ButtonPropTypes, string | JSXElementConstructor<any>> | ReactElement<ButtonPropTypes, string | JSXElementConstructor<...>>[]"
+          },
+          "required": false,
+          "description": "Defines the actions of the `ActionSheet`.\n\n__Note:__ Although this slot accepts all HTML Elements, it is strongly recommended that you only use `Buttons` in order to preserve the intended design."
+        },
+        "hideCancelButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Hides the cancel button below the action buttons on mobile devices. No cancel button will be shown on desktop and tablet devices."
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "{ actionSheetMobileContent?: { role?: string; }; }"
+          },
+          "required": false,
+          "description": "Defines internally used accessibility properties/attributes."
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "PopupAccessibleRole | \"None\" | \"Dialog\" | \"AlertDialog\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "Represents no ARIA role."
+              },
+              {
+                "value": "\"Dialog\"",
+                "description": "Represents the ARIA role \"dialog\"."
+              },
+              {
+                "value": "\"AlertDialog\"",
+                "description": "Represents the ARIA role \"alertdialog\"."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Dialog\""
+              },
+              {
+                "value": "\"AlertDialog\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Dialog\""
+          }
+        },
+        "allowTargetOverlap": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines if there is no enough space, the component can be placed\nover the target.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideArrow": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component arrow is hidden.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "horizontalAlign": {
+          "type": {
+            "name": "enum",
+            "raw": "PopoverHorizontalAlign | \"Center\" | \"Start\" | \"End\" | \"Stretch\"",
+            "value": [
+              {
+                "value": "\"Center\"",
+                "description": "Popover is centered."
+              },
+              {
+                "value": "\"Start\"",
+                "description": "Popover is aligned with the start of the target."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Popover is aligned with the end of the target."
+              },
+              {
+                "value": "\"Stretch\"",
+                "description": "Popover is stretched."
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Stretch\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the horizontal alignment of the component.",
+          "defaultValue": {
+            "value": "\"Center\""
+          }
+        },
+        "initialFocus": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the ID of the HTML Element, which will get the initial focus.\n\n**Note:** If an element with `autofocus` attribute is added inside the component,\n`initialFocus` won't take effect."
+        },
+        "modal": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should close when\nclicking/tapping outside the popover.\nIf enabled, it blocks any interaction with the background.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if the element is open\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "opener": {
+          "type": {
+            "name": "string | HTMLElement"
+          },
+          "required": false,
+          "description": "Defines the ID or DOM Reference of the element at which the popover is shown.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
+        },
+        "placement": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Start\" | \"End\" | PopoverPlacement | \"Top\" | \"Bottom\"",
+            "value": [
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Start\"",
+                "description": "Popover will be placed at the start of the reference element."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Popover will be placed at the end of the reference element."
+              },
+              {
+                "value": "\"Top\"",
+                "description": "Popover will be placed at the top of the reference element."
+              },
+              {
+                "value": "\"Bottom\"",
+                "description": "Popover will be placed at the bottom of the reference element."
+              },
+              {
+                "value": "\"Top\""
+              },
+              {
+                "value": "\"Bottom\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines on which side the component is placed at.",
+          "defaultValue": {
+            "value": "\"End\""
+          }
+        },
+        "preventFocusRestore": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "preventInitialFocus": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "resizable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is resizable.\n**Note:** This property is effective only on desktop devices.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "verticalAlign": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Center\" | \"Stretch\" | \"Top\" | \"Bottom\" | PopoverVerticalAlign",
+            "value": [
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Stretch\""
+              },
+              {
+                "value": "\"Top\""
+              },
+              {
+                "value": "\"Bottom\""
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Top\"",
+                "description": "Popover will be placed at the top of the reference control."
+              },
+              {
+                "value": "\"Bottom\"",
+                "description": "Popover will be placed at the bottom of the reference control."
+              },
+              {
+                "value": "\"Stretch\"",
+                "description": "Popover will be streched"
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the vertical alignment of the component.",
+          "defaultValue": {
+            "value": "\"Center\""
+          }
+        },
+        "footer": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the footer HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onBeforeClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, PopupBeforeCloseEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
+        },
+        "onBeforeOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ResponsivePopoverDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "AnalyticalCardHeader": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `AnalyticalCardHeader` is a KPI header, enabling the AnalyticalCard representation. If this header is used, the `Card` should only receive a chart as content and no footer area.\n\n__Note:__ This component should only be used as header for the `Card` component.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "The title of the card"
+        },
+        "titleTextLevel": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Determines the ARIA level of the `titleText`.\n\n__Note:__ Defining a `titleTextLevel` will apply the `aria-level` attribute with a value from 1 to 6.",
+          "defaultValue": {
+            "value": "3"
+          }
+        },
+        "subtitleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "The subtitle of the card"
+        },
+        "trend": {
+          "type": {
+            "name": "enum",
+            "raw": "DeviationIndicator | \"Down\" | \"Up\" | \"None\"",
+            "value": [
+              {
+                "value": "\"Down\""
+              },
+              {
+                "value": "\"Up\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Down\""
+              },
+              {
+                "value": "\"Up\""
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "The direction of the trend arrow. Shows deviation for the value of the main number indicator.",
+          "defaultValue": {
+            "value": "`\"None\"`"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "The numeric value of the main number indicator."
+        },
+        "scale": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the unit of measurement (scaling prefix) for the main indicator.\nFinancial characters can be used for currencies and counters. The International System of Units (SI) prefixes can be used."
+        },
+        "state": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | ValueColor | \"Critical\" | \"Error\" | \"Good\" | \"Neutral\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Critical\"",
+                "description": "Critical value color."
+              },
+              {
+                "value": "\"Error\"",
+                "description": "Error value color."
+              },
+              {
+                "value": "\"Good\"",
+                "description": "Good value color."
+              },
+              {
+                "value": "\"Neutral\"",
+                "description": "Neutral value color."
+              },
+              {
+                "value": "\"None\"",
+                "description": "None value color.\n\n__Note__: \"None\" has the same color as \"Neutral\" but doesn't add the tooltip and accessible-name for the numeric content."
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Error\""
+              },
+              {
+                "value": "\"Good\""
+              },
+              {
+                "value": "\"Neutral\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "The semantic color which represents the state of the main number indicator.\nAvailable options are: <ul> <li><code>None</code></li> <li><code>Error</code></li> <li><code>Critical</code></li> <li><code>Good</code></li> <li><code>Neutral</code></li></ul>\n\n__Note__: \"None\" has the same color as \"Neutral\" but doesn't add the tooltip and accessible-name for the numeric content.",
+          "defaultValue": {
+            "value": "`\"None\"`"
+          }
+        },
+        "description": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Additional text which adds more details to what is shown in the numeric header."
+        },
+        "status": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the status text."
+        },
+        "unitOfMeasurement": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "General unit of measurement for the header. Displayed as side information to the subtitle."
+        },
+        "onClick": {
+          "type": {
+            "name": "MouseEventHandler<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Fired when the `AnalyticalCardHeader` is clicked."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Additional side number indicators. For example \"Deviation\" and \"Target\". Not more than two side indicators should be used.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `NumericSideIndicator` in order to preserve the intended design."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "AnalyticalTable": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `AnalyticalTable` provides a set of convenient functions for responsive table design, including virtualization of rows and columns, infinite scrolling and customizable columns that will, unless otherwise defined, distribute the available space equally among themselves.\nIt also provides several possibilities for working with the data, including sorting, filtering, grouping and aggregation.\n\n__Note:__ The `AnalyticalTable` has some limitations and includes features that do not have a defined design specification.\nTo follow UXC guidelines, please refer to the table below:\n\n| Function / Feature                    | Reason                                                                                                                                                                                                                                                   |\n|---------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| No sticky columns/rows                | Not supported due to technical limitations.                                                                                                                                                                                                              |\n| Pop-in behavior                       | The `sap.ui.table` doesn’t support pop-in behavior (unlike `sap.m.Table`); it’s unclear whether this should be part of the design.                                                                                                                       |\n| `visibleRowCountMode: \"Auto\"`         | `\"AutoWithEmptyRows\"` is preferred. `\"Auto\"` mode can lead to inconsistent table heights depending on the container.                                                                                                                                     |\n| `alwaysShowBusyIndicator`             | Should generally be `true`, only if loading times are over 1 second, the default skeleton loading indicator is sufficient: [Fiori Skeleton Loading](https://www.sap.com/design-system/fiori-design-ios/ui-elements/patterns/skeleton-loading/?external). |\n| `scaleWidthMode`                      | Only the default mode is available out of the box for the `sap.m.Table`; similar behavior to the `\"Grow\"` mode can be achieved in `sap.ui.table` using `autoResizeColumn`.                                                                               |\n| `renderRowSubComponent`               | There is no design/UX concept for this functionality.                                                                                                                                                                                                 |\n| `useIndeterminateRowSelection`        | There is no design/UX concept for this functionality.                                                                                                                                                                                                 |\n| `useRowDisableSelection` (deprecated) | Table rows should not be disabled.                                                                                                                                                                                                                       |\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "columns": {
+          "type": {
+            "name": "AnalyticalTableColumnDefinition[]"
+          },
+          "required": true,
+          "description": "Defines the columns array where you can define the configuration for each column.\n\n__Must be memoized!__"
+        },
+        "data": {
+          "type": {
+            "name": "Record<string, any>[]"
+          },
+          "required": true,
+          "description": "The data array that you want to display on the table.\n\n__Must be memoized!__"
+        },
+        "header": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "Component or text rendered in the header section of the `AnalyticalTable`.\n\n__Note:__ If not set, it will be hidden."
+        },
+        "extension": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "Extension section of the Table. If not set, no extension area will be rendered"
+        },
+        "minRows": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The minimum number of rows that are displayed. If the data contains fewer entries than `minRows`, it will be filled with empty rows.\n\n__Note:__\n- To prevent the height of the table from jumping when e.g. filtering or fetching data, it's recommended setting `minRows` to the same value as `visibleRows`.\n- Values less than 1 are __not__ supported!",
+          "defaultValue": {
+            "value": "5"
+          }
+        },
+        "visibleRowCountMode": {
+          "type": {
+            "name": "enum",
+            "raw": "AnalyticalTableVisibleRowCountMode | \"Fixed\" | \"Auto\" | \"AutoWithEmptyRows\" | \"Interactive\"",
+            "value": [
+              {
+                "value": "\"Fixed\"",
+                "description": "The number of visible rows displayed is defined by the `visibleRows` prop. If the prop is not set, 15 rows will be shown."
+              },
+              {
+                "value": "\"Auto\"",
+                "description": "The number of visible rows depends on the height of the surrounding container. Since this mode can cause the table height to change when filtering, fetching data, etc., we recommend using the `\"AutoWithEmptyRows\"` mode instead.\n\n__Note:__ It's recommended to use a fixed height for the outer container.\n\n__Note:__ When this is active, `visibleRows` prop has no effect."
+              },
+              {
+                "value": "\"AutoWithEmptyRows\"",
+                "description": "The number of rows displayed depends on the height of the surrounding container, if not enough visible rows are available, empty rows are displayed.\n\n__Note:__ It's recommended to use a fixed height for the outer container.\n\n__Note:__ When this is active, `visibleRows` prop has no effect."
+              },
+              {
+                "value": "\"Interactive\"",
+                "description": "Adds a resizer to the bottom of the table to dynamically add or remove visible rows.\nThe initial number of rows is defined by the `visibleRows` prop."
+              },
+              {
+                "value": "\"Fixed\""
+              },
+              {
+                "value": "\"Auto\""
+              },
+              {
+                "value": "\"AutoWithEmptyRows\""
+              },
+              {
+                "value": "\"Interactive\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines how the table will render rows.\n\n- __\"Fixed\":__ The table always has as many rows as defined in the `visibleRows` prop.\n- __\"Auto\":__ The number of visible rows depends on the height of the surrounding container. Since this mode can cause the table height to change when filtering, fetching data, etc., we recommend using the `\"AutoWithEmptyRows\"` mode instead.\n- __\"AutoWithEmptyRows\":__ The number of rows displayed depends on the height of the surrounding container, if not enough visible rows are available, empty rows are displayed.\n- __\"Interactive\":__ Adds a resizer to the bottom of the table to dynamically add or remove visible rows. The initial number of rows is defined by the `visibleRows` prop.\n\n__Note:__ When `\"Auto\"` or `\"AutoWithEmptyRows\"` is enabled, we recommend using a fixed height for the parent container.",
+          "defaultValue": {
+            "value": "\"Fixed\""
+          }
+        },
+        "additionalEmptyRowsCount": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Specifies the number of additional empty rows added to the bottom of a table that is normally __non__ scrollable.\nUse this prop if you want to ensure that the table is scrollable.\n\n__Note:__ It's recommended to use this prop only if `infiniteScroll` is applied and where assessing scrollability is not possible across various resolutions or datasets.\nE.g., when using `visibleRowCountMode` with values `\"Auto\"` or `\"AutoWithEmptyRows\"`.\n\n__Note:__ This prop has no effect if the table is already scrollable without additional empty rows."
+        },
+        "visibleRows": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The number of rows visible without going into overflow.\n\n__Note:__\n- If the data contains more entries than the `visibleRow` count, a vertical scrollbar is rendered and the table goes into overflow.\n- To prevent the height of the table from jumping when e.g. filtering or fetching data, it's recommended setting `minRows` to the same value as `visibleRows`.",
+          "defaultValue": {
+            "value": "15"
+          }
+        },
+        "adjustTableHeightOnPopIn": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the row height of popped-in columns should be considered when calculating the body height of the table.\n\n__Note:__ If set so `true` the table will change its height depending on whether columns are popped in or not."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether a loading indicator should be shown.\n\n__Note:__ If the data array is not empty and loading is set to `true` a `BusyIndicator` will be displayed on top of the table, otherwise a skeleton placeholder will be shown. You can control this behavior via the `alwaysShowBusyIndicator` prop."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "showOverlay": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Setting this prop to `true` will show an overlay on top of the AnalyticalTable content preventing users from interacting with it."
+        },
+        "alwaysShowBusyIndicator": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "If `true`, always shows the `BusyIndicator` component when loading instead of the skeleton loader.\n\n__We recommend setting this prop to `true` when loading times are under 1 second.__"
+        },
+        "noDataText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text shown if the data array is empty or a filtered table doesn't return results.\n\n__Note:__ If `noDataText` isn't set, the default text displayed is \"No data\". For filtered tables, it will show \"No data found. Try adjusting the filter settings.\" instead."
+        },
+        "rowHeight": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the height of the rows and header row.\n\n__Note:__ This prop overrides the default height. If you want to use the default height after you have set a custom height, you will have to remove this prop and remount the component.\n\n__Note:__ To preserve the intended design, it is not recommended to set a row height with active elements such as buttons below `32px` for content density \"Compact\" and `44px` for content density \"Cozy\"."
+        },
+        "headerRowHeight": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the height of the header row.\n\n__Note:__ If this property is set, it overwrites the height set in `rowHeight` for the header row.\n\n__Note:__ This prop overrides the default height. If you want to use the default height after you have set a custom height, you will have to remove this prop and remount the component."
+        },
+        "retainColumnWidth": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the table should retain its column width, when a column has been manually resized and the container width has changed."
+        },
+        "alternateRowColor": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the table should display rows with alternating row colors."
+        },
+        "withNavigationHighlight": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the table should add an extra column at the end of the rows for displaying a navigation highlight."
+        },
+        "withRowHighlight": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the table should add an extra column at the start of the rows for displaying row highlights, based on the `highlightField` prop.\n\n__Note:__ When enabled, the table automatically adds a column with `accessor=\"status\"`. If you have a custom column using this accessor, change the `highlightField` prop to a different value to avoid conflicts."
+        },
+        "highlightField": {
+          "type": {
+            "name": "string | ((row: RowType) => HighlightColor)"
+          },
+          "required": false,
+          "description": "Accessor for showing the row highlights. Only taken into account when `withRowHighlight` is set.\n\nThe value of this prop can either be a `string` pointing to a `ValueState` or an `IndicationColor` in your dataset\nor an accessor function which should return a `ValueState` or an `IndicationColor`.\n\n__Note:__ If a function is used, it __must be memoized!__\n@since 1.26.0",
+          "defaultValue": {
+            "value": "\"status\""
+          }
+        },
+        "filterable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether columns are filterable.\n\n__Note:__ The table is implementing \"top-down\" (parent/root node first) filtering."
+        },
+        "sortable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether columns are sortable.",
+          "defaultValue": {
+            "value": "true"
+          }
+        },
+        "groupable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether columns are groupable.\n\n__Note:__ This prop has no effect when `isTreeTable` is true or `renderRowSubComponent` is set.\n\n__Note:__ It is not recommended to use grouping in combination with `infiniteScroll` as there is no concept for this configuration."
+        },
+        "groupBy": {
+          "type": {
+            "name": "string[]"
+          },
+          "required": false,
+          "description": "Group table rows by adding the column's `accessor` or `id` to the array.\n\n__Must be memoized!__\n\n__Note:__ This prop has no effect when `isTreeTable` is true or `renderRowSubComponent` is set."
+        },
+        "selectionBehavior": {
+          "type": {
+            "name": "enum",
+            "raw": "AnalyticalTableSelectionBehavior | \"Row\" | \"RowOnly\" | \"RowSelector\"",
+            "value": [
+              {
+                "value": "\"Row\"",
+                "description": "A selection column is rendered along with the normal columns. The whole row is selectable."
+              },
+              {
+                "value": "\"RowOnly\"",
+                "description": "No selection column is rendered along with the normal columns. The whole row is selectable."
+              },
+              {
+                "value": "\"RowSelector\"",
+                "description": "The row is only selectable by clicking on the corresponding field in the selection column."
+              },
+              {
+                "value": "\"Row\""
+              },
+              {
+                "value": "\"RowOnly\""
+              },
+              {
+                "value": "\"RowSelector\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the selection behavior of the table.\n\n- __\"Row\":__ A selection column is rendered along with the normal columns. The whole row is selectable.\n- __\"RowOnly\":__ No selection column is rendered along with the normal columns. The whole row is selectable.\n- __\"RowSelector\":__ The row is only selectable by clicking on the corresponding field in the selection column.\n\n__Default:__ `\"Row\"`"
+        },
+        "selectionMode": {
+          "type": {
+            "name": "enum",
+            "raw": "AnalyticalTableSelectionMode | \"None\" | \"Single\" | \"Multiple\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "The rows are not selectable."
+              },
+              {
+                "value": "\"Single\"",
+                "description": "Only a single row is selectable. Clicking on another row will unselect the previously selected row."
+              },
+              {
+                "value": "\"Multiple\"",
+                "description": "Multiple rows are selectable."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Single\""
+              },
+              {
+                "value": "\"Multiple\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the `SelectionMode` of the table.\n\n- __\"None\":__ The rows are not selectable.\n- __\"Single\":__ You can select only one row at once. Clicking on another row will unselect the previously selected row.\n- __\"Multiple\":__ You can select multiple rows.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "scaleWidthMode": {
+          "type": {
+            "name": "enum",
+            "raw": "AnalyticalTableScaleWidthMode | \"Default\" | \"Smart\" | \"Grow\"",
+            "value": [
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Smart\""
+              },
+              {
+                "value": "\"Grow\""
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Smart\""
+              },
+              {
+                "value": "\"Grow\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the column growing behaviour. Possible Values:\n\n- **Default**: The available space of the table is distributed evenly for columns without fixed width. If the minimum width of all columns is reached, horizontal scrolling will be enabled.\n- **Smart**: Every column gets the space it needs for displaying the full header text. If all header texts need more space than the available table width, horizontal scrolling will be enabled. If there is space left, columns with a long text will get more space until there is no more table space left.\n- **Grow**: Every column gets the space it needs for displaying its full header text and full text content of all cells. If it requires more space than the table has, horizontal scrolling will be enabled. To prevent huge header text from polluting the table, a max-width of 700px is applied to each column. It can be overwritten by setting the respective column property.\n\n__Note:__\n- Columns without data `accessor` are ignored by the `Smart` and `Grow` modes. You can use the `scaleWidthModeOptions` property on the column definition to add custom strings for the internal width calculation.\n- For performance reasons, the `Smart` and `Grow` modes base their calculation for table cell width on a subset of column cells. If the first 20 cells of a column are significantly smaller than the rest of the column cells, the content may still not be fully displayed for all cells.\n- Only the default mode is available out of the box for the `sap.m.Table`; similar behavior to the `\"Grow\"` mode can be achieved in `sap.ui.table` using `autoResizeColumn`.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "scaleXFactor": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the number of the CSS `scaleX(sx: number)` function. `sx` is representing the abscissa of the scaling vector."
+        },
+        "columnOrder": {
+          "type": {
+            "name": "string[]"
+          },
+          "required": false,
+          "description": "Defines the columns order by their `accessor` or `id`.\n\n__Must be memoized!__"
+        },
+        "infiniteScroll": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether infinite scroll is active.\n\n__Note:__ It is not recommended to use this prop in combination with a grouped table, as there is no concept for this configuration.\n\n__Note:__ To prevent the table state from resetting when the data is updated, please see [this recipe](https://ui5.github.io/webcomponents-react/v2/?path=/docs/data-display-analyticaltable-recipes--docs#how-to-stop-the-table-state-from-automatically-resetting-when-the-data-changes)."
+        },
+        "infiniteScrollThreshold": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The `infiniteScrollThreshold` defines at how many remaining rows the `onLoadMore` event should be fired.\n\nExample: Your initial dataset consists of 50 entries and you want to load more data when the user scrolled to the 40th row. Then you should set the `infiniteScrollThreshold` to 10.",
+          "defaultValue": {
+            "value": "20"
+          }
+        },
+        "globalFilterValue": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value that should be filtered on across all rows.\n\n__Note:__ This prop is not supported for tree-tables. You can enable it by creating your own global-filter function. You can find out more about this in the [react-table v7 documentation](https://github.com/TanStack/table/blob/v7/docs/src/pages/docs/api/useGlobalFilter.md)."
+        },
+        "reactTableOptions": {
+          "type": {
+            "name": "Record<string, unknown>"
+          },
+          "required": false,
+          "description": "Additional options which will be passed to [v7 react-table´s useTable hook](https://github.com/TanStack/table/blob/v7/docs/src/pages/docs/api/useTable.md#table-options)\n\n__Must be memoized!__"
+        },
+        "tableHooks": {
+          "type": {
+            "name": "((hooks: ReactTableHooks) => void)[]"
+          },
+          "required": false,
+          "description": "You can use this prop to add custom hooks to the table.\n\n__Must be memoized!__",
+          "defaultValue": {
+            "value": "[]"
+          }
+        },
+        "subRowsKey": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the key for nested rows.\n\n__Note__: You can also specify deeply nested sub-rows with accessors like `values.subRows`.",
+          "defaultValue": {
+            "value": "\"subRows\""
+          }
+        },
+        "selectedRowIds": {
+          "type": {
+            "name": "Record<string, boolean>"
+          },
+          "required": false,
+          "description": "The key must consist of a valid `rowId` like `{ 2: true }` or `{ '0.2.0': true }` for nested rows.\n\n__Note:__ This prop updates the internal table state and must therefore be memoized!"
+        },
+        "isTreeTable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the table should act as tree-table."
+        },
+        "overscanCountHorizontal": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The amount of columns to load both behind and ahead of the current window range.",
+          "defaultValue": {
+            "value": "5"
+          }
+        },
+        "overscanCount": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The amount of rows to load both behind and ahead of the current window range."
+        },
+        "renderRowSubComponent": {
+          "type": {
+            "name": "(row: RowType) => ReactNode"
+          },
+          "required": false,
+          "description": "Defines the subcomponent that should be displayed below each row.\n\n__Must be memoized!__\n\n__Note:__\n- __There is no design concept regarding this functionality!__\n- When rendering active elements inside the subcomponent, make sure to add the `data-subcomponent-active-element' attribute, otherwise focus behavior won't be consistent.\n- Subcomponents can affect performance, especially when used in a tree table (`isTreeTable={true}`). If you face performance issues, please try memoizing your subcomponent."
+        },
+        "subComponentsBehavior": {
+          "type": {
+            "name": "enum",
+            "raw": "AnalyticalTableSubComponentsBehavior | \"Expandable\" | \"Visible\" | \"IncludeHeight\" | \"IncludeHeightExpandable\"",
+            "value": [
+              {
+                "value": "\"Expandable\"",
+                "description": "Render subcomponents as expandable container of each row."
+              },
+              {
+                "value": "\"Visible\"",
+                "description": "Render subcomponents below each row."
+              },
+              {
+                "value": "\"IncludeHeight\"",
+                "description": "Render subcomponents below each row. The height of each initially visible subcomponent (defined by `visibleRows`) is taken into account when defining the body height of the table.\n\n__Note:__ `AnalyticalTableVisibleRowCountMode.Interactive` is not supported with this mode."
+              },
+              {
+                "value": "\"IncludeHeightExpandable\"",
+                "description": "Render subcomponents as expandable container of each row. The height of each expanded subcomponent of visible rows (defined by `visibleRows`) is taken into account when defining the body height of the table, so that the height of the table changes when a subcomponent is expanded/collapsed.\n\n__Note:__ This mode can lead to performance degradation, please use with caution!\n__Note:__ `AnalyticalTableVisibleRowCountMode.Interactive` is not supported with this mode."
+              },
+              {
+                "value": "\"Expandable\""
+              },
+              {
+                "value": "\"Visible\""
+              },
+              {
+                "value": "\"IncludeHeight\""
+              },
+              {
+                "value": "\"IncludeHeightExpandable\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the rendering and height calculation behavior of subcomponents when `renderRowSubComponent` is used.\n\n- __\"Expandable\":__ Render subcomponents as expandable container of each row.\n- __\"Visible\":__ Render subcomponents below each row.\n- __\"IncludeHeight\":__ Render subcomponents below each row. The height of each initially visible subcomponent (defined by `visibleRows`) is taken into account when defining the body height of the table.\n- __\"IncludeHeightExpandable\":__ Render subcomponents as expandable container of each row. The height of each expanded subcomponent of visible rows (defined by `visibleRows`) is taken into account when defining the body height of the table, so that the height of the table changes when a subcomponent is expanded/collapsed. (since: v1.23.0)\n@since 1.19.0",
+          "defaultValue": {
+            "value": "\"Expandable\""
+          }
+        },
+        "markNavigatedRow": {
+          "type": {
+            "name": "(row: RowType) => boolean"
+          },
+          "required": false,
+          "description": "This callback can be used to programmatically show an indicator for navigated rows. It has no effect if `withNavigationHighlight` is not set.\n\n__Must be memoized!__"
+        },
+        "onSort": {
+          "type": {
+            "name": "(e: CustomEvent<{ column: ColumnType; sortDirection: string; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when the sorting of the rows changes."
+        },
+        "onGroup": {
+          "type": {
+            "name": "(e: CustomEvent<{ column: ColumnType; groupedColumns: string[]; isGrouped: boolean; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when the grouping of the rows changes."
+        },
+        "onRowSelect": {
+          "type": {
+            "name": "(e: CustomEvent<{ row?: RowType; isSelected?: boolean; allRowsSelected: boolean; allVisibleRowsSelected: boolean; rowsById: Record<string, RowType>; selectedRowIds: Record<string, boolean>; nativeDetail: number; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when a row is selected or unselected."
+        },
+        "onRowClick": {
+          "type": {
+            "name": "(e: OnRowClickEvent) => void"
+          },
+          "required": false,
+          "description": "Fired when a row is clicked"
+        },
+        "onRowExpandChange": {
+          "type": {
+            "name": "(e: CustomEvent<{ row: RowType; column: ColumnType; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when a row is expanded or collapsed"
+        },
+        "onColumnsReorder": {
+          "type": {
+            "name": "(e: CustomEvent<{ columnsNewOrder: ColumnType[]; column: ColumnType; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when the columns order is changed."
+        },
+        "onLoadMore": {
+          "type": {
+            "name": "(e: CustomEvent<{ rowCount: number; totalRowCount: number; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `infiniteScrollThreshold` is reached.\n\n__Note:__ When used in a vertically resizable table (`visibleRowCountMode: AnalyticalTableVisibleRowCountMode.Interactive`), the event is also fired if all available rows are displayed after resizing.\nYou can distinguish between the scroll and custom event by checking the `event.type`.\n@param e.detail.rowCount - The number of rows\n@param e.detail.totalRowCount - The total number of rows, including sub-rows"
+        },
+        "onTableScroll": {
+          "type": {
+            "name": "(e: CustomEvent<{ rows: RowType[]; rowElements: HTMLCollection; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when the body of the table is scrolled.\n\n__Note:__ This callback __must be memoized__! Since it is triggered on __every scroll event__,\nnon-memoized or expensive calculations can have a __huge impact on performance__ and cause visible lag.\nThrottling or debouncing is always recommended to reduce performance overhead."
+        },
+        "onAutoResize": {
+          "type": {
+            "name": "(e: OnAutoResizeMouseEvent) => void"
+          },
+          "required": false,
+          "description": "Fired when the table is resized by double-clicking the Resizer.\n\n__Note:__ Auto-resize is only available on columns that have the `autoResizable` option set to `true`."
+        },
+        "onFilter": {
+          "type": {
+            "name": "(e: OnFilterParam) => void"
+          },
+          "required": false,
+          "description": "Fired when a filter is applied to a column."
+        },
+        "NoDataComponent": {
+          "type": {
+            "name": "ComponentType<{ noDataText: string; className: string; noDataReason: AnalyticalTableNoDataReason | \"Empty\" | \"Filtered\"; accessibleRole: \"gridcell\"; }>"
+          },
+          "required": false,
+          "description": "Component that will be rendered when the table is not loading and has no data.\n\n__Note:__\n- Although this prop accepts all React components, it is strongly recommended that you use `IllustratedMessage` with `design=\"Auto\"` to preserve the intended design.\n- For `visibleRowCountMode`s \"Auto\" and \"AutoWithEmptyRows\", the `NoDataComponent` spreads to the available space below the header row, otherwise the `minRows` prop defines the minimum height of the table body.\n- To prevent overflow, ensure the table body is at least **60 px** tall when displaying an `IllustratedMessage`.",
+          "defaultValue": {
+            "value": "DefaultNoDataComponent"
+          }
+        },
+        "tableInstance": {
+          "type": {
+            "name": "Ref<TableInstance>"
+          },
+          "required": false,
+          "description": "Exposes the internal table instance.\nThis object will contain all [instance properties (react-table v7)](https://github.com/TanStack/table/blob/v7/docs/src/pages/docs/api/useTable.md#instance-properties)\nof the `useTable` hook and all instance properties from `useColumnOrder`, `useExpanded`, `useFilters`,\n`useGlobalFilter`, `useGroupBy`,`useResizeColumns`, `useRowSelect` and `useSortBy` plugin hooks.\n\n**Note**: Use this prop with care, some properties might have an impact on the internal `AnalyticalTable` implementation."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<AnalyticalTableDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "FilterBar": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `FilterBar` displays filters in a user-friendly manner to populate values for a query. It consists of a row containing the `VariantManagement` or a title, the related buttons, and an area underneath displaying the filters. The filters are arranged in a logical row that is divided depending on the space available and the width of the filters. The area containing the filters can be hidden or shown using the \"Hide FilterBar / Show FilterBar\" button, the \"Filters\" button shows the filter dialog.\nIn this dialog, the consumer has full control over the FilterBar. The filters in this dialog are displayed in one column and organized in groups. Each filter can be marked as visible in the FilterBar by selecting the respective row.\n\n__Responsiveness:__\nThe name of the view or title is always visible. The filter area varies:\n\n* Desktop: Expanded or collapsed by default\n* Tablet: Collapsed by default\n* Phone: Not displayed. Accessible through filter dialog.\n\n__Note:__ When `hideToolbar` is set to `true`, filters are always visible.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": true,
+          "description": "Defines the filters of the `FilterBar`.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `FilterGroupItems` in order to preserve the intended design."
+        },
+        "search": {
+          "type": {
+            "name": "ReactElement<InputPropTypes, string | JSXElementConstructor<any>>"
+          },
+          "required": false,
+          "description": "Defines the search field rendered as first filter item.\n\n__Note:__ By default, `placeholder`, `icon`, `noTypeahead`, `showClearIcon`, and `type` are applied to the search input. Only `placeholder` and `noTypeahead` can be overridden.\n\n__Note:__ The field is only available in the FilterBar not inside the filter configuration dialog."
+        },
+        "header": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "Specifies header text or variant management that is shown in the toolbar on the first position\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `VariantManagement`, `Text` or `Title` in order to preserve the intended design.\n\n__Note:__ If `hideToolbar` is `true` this prop has no effect."
+        },
+        "hideToolbar": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the toolbar on top of the filter items is displayed.\n\n__Note:__ If set to `true`, `header` and the \"Hide/Show FilterBar\" button are not available, the `filterBarCollapsed` prop has no effect and the rest of the buttons are moved to the bottom right side of the filter area."
+        },
+        "filterBarCollapsed": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the `FilterBar` is collapsed.\n\n__Note:__ This prop has no effect if `hideToolbar` is `true`."
+        },
+        "filterContainerWidth": {
+          "type": {
+            "name": "Width<string | number>"
+          },
+          "required": false,
+          "description": "Defines the width of the `FilterGroupItems`.\n\n__Note:__ If your filter elements have an internal `minWidth`, please make sure to overwrite it with `minWidth:'auto'` or the corresponding `filterContainerWidth` otherwise it can lead to unintended behavior."
+        },
+        "considerGroupName": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the `groupName` of the `FilterGroupItems` is displayed."
+        },
+        "showClearOnFB": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the \"Clear\" button is displayed in the `FilterBar`."
+        },
+        "showGoOnFB": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the \"Go\" button is displayed in the `FilterBar`."
+        },
+        "hideFilterConfiguration": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the \"Filter\" button is displayed in the `FilterBar`.\n\n__Note:__ Clicking on the button will open the filter configuration dialog, where you can add/remove filters to the `FilterBar`."
+        },
+        "showResetButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the \"Reset\" button is displayed in the filter configuration dialog."
+        },
+        "hideToggleFiltersButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the \"Hide/Show Filters\" button is displayed in the `FilterBar`.\n\n__Note:__ If `hideToolbar` is `true` or the FilterBar is used on mobile, this prop has no effect."
+        },
+        "activeFiltersCount": {
+          "type": {
+            "name": "string | number"
+          },
+          "required": false,
+          "description": "Defines the number of active filters displayed in the \"Filter\" button.\n\n__Note__: If `hideFilterConfiguration` is `true` this prop has no effect."
+        },
+        "showRestoreOnFB": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the \"Restore\" button is displayed in the `FilterBar`."
+        },
+        "enableReordering": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Allow changing the order of filters in the filter configuration dialog."
+        },
+        "as": {
+          "type": {
+            "name": "enum",
+            "raw": "keyof HTMLElementTagNameMap",
+            "value": [
+              {
+                "value": "\"object\""
+              },
+              {
+                "value": "\"slot\""
+              },
+              {
+                "value": "\"style\""
+              },
+              {
+                "value": "\"title\""
+              },
+              {
+                "value": "\"search\""
+              },
+              {
+                "value": "\"header\""
+              },
+              {
+                "value": "\"link\""
+              },
+              {
+                "value": "\"small\""
+              },
+              {
+                "value": "\"sub\""
+              },
+              {
+                "value": "\"sup\""
+              },
+              {
+                "value": "\"map\""
+              },
+              {
+                "value": "\"a\""
+              },
+              {
+                "value": "\"abbr\""
+              },
+              {
+                "value": "\"address\""
+              },
+              {
+                "value": "\"area\""
+              },
+              {
+                "value": "\"article\""
+              },
+              {
+                "value": "\"aside\""
+              },
+              {
+                "value": "\"audio\""
+              },
+              {
+                "value": "\"b\""
+              },
+              {
+                "value": "\"base\""
+              },
+              {
+                "value": "\"bdi\""
+              },
+              {
+                "value": "\"bdo\""
+              },
+              {
+                "value": "\"blockquote\""
+              },
+              {
+                "value": "\"body\""
+              },
+              {
+                "value": "\"br\""
+              },
+              {
+                "value": "\"button\""
+              },
+              {
+                "value": "\"canvas\""
+              },
+              {
+                "value": "\"caption\""
+              },
+              {
+                "value": "\"cite\""
+              },
+              {
+                "value": "\"code\""
+              },
+              {
+                "value": "\"col\""
+              },
+              {
+                "value": "\"colgroup\""
+              },
+              {
+                "value": "\"data\""
+              },
+              {
+                "value": "\"datalist\""
+              },
+              {
+                "value": "\"dd\""
+              },
+              {
+                "value": "\"del\""
+              },
+              {
+                "value": "\"details\""
+              },
+              {
+                "value": "\"dfn\""
+              },
+              {
+                "value": "\"dialog\""
+              },
+              {
+                "value": "\"div\""
+              },
+              {
+                "value": "\"dl\""
+              },
+              {
+                "value": "\"dt\""
+              },
+              {
+                "value": "\"em\""
+              },
+              {
+                "value": "\"embed\""
+              },
+              {
+                "value": "\"fieldset\""
+              },
+              {
+                "value": "\"figcaption\""
+              },
+              {
+                "value": "\"figure\""
+              },
+              {
+                "value": "\"footer\""
+              },
+              {
+                "value": "\"form\""
+              },
+              {
+                "value": "\"h1\""
+              },
+              {
+                "value": "\"h2\""
+              },
+              {
+                "value": "\"h3\""
+              },
+              {
+                "value": "\"h4\""
+              },
+              {
+                "value": "\"h5\""
+              },
+              {
+                "value": "\"h6\""
+              },
+              {
+                "value": "\"head\""
+              },
+              {
+                "value": "\"hgroup\""
+              },
+              {
+                "value": "\"hr\""
+              },
+              {
+                "value": "\"html\""
+              },
+              {
+                "value": "\"i\""
+              },
+              {
+                "value": "\"iframe\""
+              },
+              {
+                "value": "\"img\""
+              },
+              {
+                "value": "\"input\""
+              },
+              {
+                "value": "\"ins\""
+              },
+              {
+                "value": "\"kbd\""
+              },
+              {
+                "value": "\"label\""
+              },
+              {
+                "value": "\"legend\""
+              },
+              {
+                "value": "\"li\""
+              },
+              {
+                "value": "\"main\""
+              },
+              {
+                "value": "\"mark\""
+              },
+              {
+                "value": "\"menu\""
+              },
+              {
+                "value": "\"meta\""
+              },
+              {
+                "value": "\"meter\""
+              },
+              {
+                "value": "\"nav\""
+              },
+              {
+                "value": "\"noscript\""
+              },
+              {
+                "value": "\"ol\""
+              },
+              {
+                "value": "\"optgroup\""
+              },
+              {
+                "value": "\"option\""
+              },
+              {
+                "value": "\"output\""
+              },
+              {
+                "value": "\"p\""
+              },
+              {
+                "value": "\"picture\""
+              },
+              {
+                "value": "\"pre\""
+              },
+              {
+                "value": "\"progress\""
+              },
+              {
+                "value": "\"q\""
+              },
+              {
+                "value": "\"rp\""
+              },
+              {
+                "value": "\"rt\""
+              },
+              {
+                "value": "\"ruby\""
+              },
+              {
+                "value": "\"s\""
+              },
+              {
+                "value": "\"samp\""
+              },
+              {
+                "value": "\"script\""
+              },
+              {
+                "value": "\"section\""
+              },
+              {
+                "value": "\"select\""
+              },
+              {
+                "value": "\"source\""
+              },
+              {
+                "value": "\"span\""
+              },
+              {
+                "value": "\"strong\""
+              },
+              {
+                "value": "\"summary\""
+              },
+              {
+                "value": "\"table\""
+              },
+              {
+                "value": "\"tbody\""
+              },
+              {
+                "value": "\"td\""
+              },
+              {
+                "value": "\"template\""
+              },
+              {
+                "value": "\"textarea\""
+              },
+              {
+                "value": "\"tfoot\""
+              },
+              {
+                "value": "\"th\""
+              },
+              {
+                "value": "\"thead\""
+              },
+              {
+                "value": "\"time\""
+              },
+              {
+                "value": "\"tr\""
+              },
+              {
+                "value": "\"track\""
+              },
+              {
+                "value": "\"u\""
+              },
+              {
+                "value": "\"ul\""
+              },
+              {
+                "value": "\"var\""
+              },
+              {
+                "value": "\"video\""
+              },
+              {
+                "value": "\"wbr\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Sets the components outer HTML tag.\n\n__Note:__ For TypeScript the types of `ref` are bound to the default tag name, if you change it you are responsible to set the respective types yourself."
+        },
+        "onToggleFilters": {
+          "type": {
+            "name": "(event: OnToggleFiltersEvent) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the `FilterBar` is collapsed/expanded."
+        },
+        "onFiltersDialogSave": {
+          "type": {
+            "name": "(event: OnFiltersDialogSaveEvent) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the \"Go\" button of the filter configuration dialog is clicked."
+        },
+        "onFiltersDialogCancel": {
+          "type": {
+            "name": "(escPressed: boolean) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the \"Cancel\" button of the filter configuration dialog is clicked or when the dialog is closed by pressing the \"Escape\" key."
+        },
+        "onFiltersDialogOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ToolbarButtonDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the filter configuration dialog is opened.\n\n__Note:__ By adding `event.preventDefault()` to the function body, opening the dialog is prevented and you can add your own custom component. Even though this is possible, we highly recommend using the default dialog in order to preserve the intended design."
+        },
+        "onAfterFiltersDialogOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "The event is fired after the filter configuration dialog has been opened."
+        },
+        "onFiltersDialogClose": {
+          "type": {
+            "name": "(closeTrigger: \"cancelButtonPressed\" | \"okButtonPressed\" | \"escPressed\") => void"
+          },
+          "required": false,
+          "description": "The event is fired when the filter configuration dialog is closed."
+        },
+        "onReorder": {
+          "type": {
+            "name": "(payload: { reorderedFilterKeys: string[]; }) => void"
+          },
+          "required": false,
+          "description": "The event is fired when a filter is reordered.\n\n__Note:__ The event is only fired if `enableReordering` is `true`."
+        },
+        "onFiltersDialogSelectionChange": {
+          "type": {
+            "name": "(payload: FiltersDialogSelectionChangePayload) => void"
+          },
+          "required": false,
+          "description": "The event is fired when a filter is selected/unselected in the filter configuration dialog."
+        },
+        "onFiltersDialogSearch": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "The event is fired on input in the filter configuration dialog search field."
+        },
+        "onClear": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ToolbarButtonDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the \"Clear\" button is clicked."
+        },
+        "onGo": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ToolbarButtonDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the \"Go\" button is clicked."
+        },
+        "onRestore": {
+          "type": {
+            "name": "(payload: RestorePayload) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the \"Reset\" button in the filter dialog is pressed, or the \"Restore\" button in the FilterBar."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "FilterGroupItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Represents a filter belonging to the `FilterBar`.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "filterKey": {
+          "type": {
+            "name": "string | number"
+          },
+          "required": true,
+          "description": "The mandatory key each `FilterGroupItem` needs to implement.\n\n__Note:__\n- `filterKey` needs to be unique for each `FilterGroupItem` per `FilterBar`.\n- Whitespace characters are not supported."
+        },
+        "children": {
+          "type": {
+            "name": "ReactElement<unknown, string | JSXElementConstructor<any>>"
+          },
+          "required": true,
+          "description": "Content of the `FilterGroupItem`.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use form elements like `Input`, `Select` or `Switch` in order to preserve the intended design."
+        },
+        "label": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the label of the `FilterGroupItem`.\n\n__Note:__ This label is used for the search in the filter configuration dialog.",
+          "defaultValue": {
+            "value": "\"\""
+          }
+        },
+        "groupName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the group name of the filter.",
+          "defaultValue": {
+            "value": "\"Basic\""
+          }
+        },
+        "labelTooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the label.\n\n__Note:__ If no `labelTooltip` is set, it uses the `label` text as tooltip."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether a loading indicator should be shown in the `FilterGroupItem`."
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the filter is required.\n\n__Note:__\n- Required filters cannot be removed from the `FilterBar`.\n- If `required` is set to `true`, the corresponding input component should also receive the `required` prop explicitly."
+        },
+        "hidden": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the filter is hidden."
+        },
+        "hiddenInFilterBar": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the filter is hidden in the `FilterBar` or only in the filter configuration dialog."
+        },
+        "considerGroupName": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the `groupName` of the `FilterGroupItems` is displayed in the filter configuration dialog."
+        },
+        "active": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the filter is displayed with a value. If it's active an indicator will be shown in the filter configuration dialog."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "FlexBox": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `FlexBox` builds the container for a flexible box layout by leveraging the CSS flexbox layout.\n\n__Note:__ Since `FlexBox` is purely a layout component, it does not have any associated global design specifications.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "alignItems": {
+          "type": {
+            "name": "enum",
+            "raw": "FlexBoxAlignItems | \"Start\" | \"Center\" | \"End\" | \"Baseline\" | \"Stretch\"",
+            "value": [
+              {
+                "value": "\"Start\"",
+                "description": "Items are aligned toward the start of the flex-direction.<br />\n<b>Note:</b> Corresponds to `flex-start`."
+              },
+              {
+                "value": "\"Center\"",
+                "description": "Items are centered.<br />\n<b>Note:</b> Corresponds to `center`."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Items are aligned toward the end of the flex-direction.<br />\n<b>Note:</b> Corresponds to `flex-end`."
+              },
+              {
+                "value": "\"Baseline\"",
+                "description": "Items are aligned by their baseline.<br />\n<b>Note:</b> Corresponds to `baseline`."
+              },
+              {
+                "value": "\"Stretch\"",
+                "description": "Items are stretched to fill the container.<br />\n<b>Note:</b> Corresponds to `stretch`."
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Baseline\""
+              },
+              {
+                "value": "\"Stretch\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Controls the alignment of items on the Cross Axis.\n\n__Note:__ Corresponds to `align-items`."
+        },
+        "direction": {
+          "type": {
+            "name": "enum",
+            "raw": "FlexBoxDirection | \"Column\" | \"ColumnReverse\" | \"Row\" | \"RowReverse\"",
+            "value": [
+              {
+                "value": "\"Column\"",
+                "description": "Items are placed top to bottom.<br />\n<b>Note:</b> Corresponds to `column`."
+              },
+              {
+                "value": "\"ColumnReverse\"",
+                "description": "Items are placed bottom to top.<br />\n<b>Note:</b> Corresponds to `column-reverse`."
+              },
+              {
+                "value": "\"Row\"",
+                "description": "Items are placed left to right in `ltr` and right to left in `rtl`.<br />\n<b>Note:</b> Corresponds to `row`."
+              },
+              {
+                "value": "\"RowReverse\"",
+                "description": "Items are placed right to left in `ltr` and left to right in `rtl`.<br />\n<b>Note:</b> Corresponds to `row-reverse`."
+              },
+              {
+                "value": "\"Column\""
+              },
+              {
+                "value": "\"ColumnReverse\""
+              },
+              {
+                "value": "\"Row\""
+              },
+              {
+                "value": "\"RowReverse\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Controls how the items are placed in the `FlexBox`.\n\n__Note:__ Corresponds to `flex-direction`."
+        },
+        "displayInline": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the `FlexBox` is in `flex` or `inline-flex` mode."
+        },
+        "fitContainer": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the `FlexBox` will be sized to completely fill its container.\n\n__Note:__ `fitContainer` only works if the height of the containing block is specified (i.e. it doesn't depend on content height)"
+        },
+        "justifyContent": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Start\" | \"Center\" | \"End\" | FlexBoxJustifyContent | \"SpaceAround\" | \"SpaceBetween\"",
+            "value": [
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Start\"",
+                "description": "Items are aligned toward the start of the flex-direction.<br />\n<b>Note:</b> Corresponds to `flex-start`."
+              },
+              {
+                "value": "\"Center\"",
+                "description": "Items are centered.<br />\n<b>Note:</b> Corresponds to `center`."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Items are aligned toward the end of the flex-direction.<br />\n<b>Note:</b> Corresponds to `flex-end`."
+              },
+              {
+                "value": "\"SpaceAround\"",
+                "description": "Items are evenly distributed on the main-axis with equal space around them.<br />\n<b>Note:</b> Corresponds to `space-around`."
+              },
+              {
+                "value": "\"SpaceBetween\"",
+                "description": "Items are evenly distributed on the main-axis; first item is on the start line, last item on the end line.<br />\n<b>Note:</b> Corresponds to `space-between`."
+              },
+              {
+                "value": "\"SpaceAround\""
+              },
+              {
+                "value": "\"SpaceBetween\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines how the browser distributes space between and around items along the main-axis.\n\n__Note:__ Corresponds to `justify-content`."
+        },
+        "wrap": {
+          "type": {
+            "name": "enum",
+            "raw": "FlexBoxWrap | \"NoWrap\" | \"Wrap\" | \"WrapReverse\"",
+            "value": [
+              {
+                "value": "\"NoWrap\"",
+                "description": "All will stay on one line. <br />\n<b>Note:</b> Corresponds to `nowrap`."
+              },
+              {
+                "value": "\"Wrap\"",
+                "description": "Items will wrap onto multiple lines. (top to bottom)<br />\n<b>Note:</b> Corresponds to `wrap`."
+              },
+              {
+                "value": "\"WrapReverse\"",
+                "description": "Items will wrap onto multiple lines. (bottom to top)<br />\n<b>Note:</b> Corresponds to `wrap-reverse`."
+              },
+              {
+                "value": "\"NoWrap\""
+              },
+              {
+                "value": "\"Wrap\""
+              },
+              {
+                "value": "\"WrapReverse\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines whether the `FlexBox` should wrap, when there is not enough space to display all items in one line.\n\n__Note:__ Corresponds to `flex-wrap`."
+        },
+        "gap": {
+          "type": {
+            "name": "Gap<string | number>"
+          },
+          "required": false,
+          "description": "Define the gap (gutters) between flex items and flex lines.\n\n__Note:__ Corresponds to the `gap` CSS Property."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Content of the `FlexBox`."
+        },
+        "as": {
+          "type": {
+            "name": "enum",
+            "raw": "keyof HTMLElementTagNameMap",
+            "value": [
+              {
+                "value": "\"object\""
+              },
+              {
+                "value": "\"slot\""
+              },
+              {
+                "value": "\"style\""
+              },
+              {
+                "value": "\"title\""
+              },
+              {
+                "value": "\"a\""
+              },
+              {
+                "value": "\"abbr\""
+              },
+              {
+                "value": "\"address\""
+              },
+              {
+                "value": "\"area\""
+              },
+              {
+                "value": "\"article\""
+              },
+              {
+                "value": "\"aside\""
+              },
+              {
+                "value": "\"audio\""
+              },
+              {
+                "value": "\"b\""
+              },
+              {
+                "value": "\"base\""
+              },
+              {
+                "value": "\"bdi\""
+              },
+              {
+                "value": "\"bdo\""
+              },
+              {
+                "value": "\"blockquote\""
+              },
+              {
+                "value": "\"body\""
+              },
+              {
+                "value": "\"br\""
+              },
+              {
+                "value": "\"button\""
+              },
+              {
+                "value": "\"canvas\""
+              },
+              {
+                "value": "\"caption\""
+              },
+              {
+                "value": "\"cite\""
+              },
+              {
+                "value": "\"code\""
+              },
+              {
+                "value": "\"col\""
+              },
+              {
+                "value": "\"colgroup\""
+              },
+              {
+                "value": "\"data\""
+              },
+              {
+                "value": "\"datalist\""
+              },
+              {
+                "value": "\"dd\""
+              },
+              {
+                "value": "\"del\""
+              },
+              {
+                "value": "\"details\""
+              },
+              {
+                "value": "\"dfn\""
+              },
+              {
+                "value": "\"dialog\""
+              },
+              {
+                "value": "\"div\""
+              },
+              {
+                "value": "\"dl\""
+              },
+              {
+                "value": "\"dt\""
+              },
+              {
+                "value": "\"em\""
+              },
+              {
+                "value": "\"embed\""
+              },
+              {
+                "value": "\"fieldset\""
+              },
+              {
+                "value": "\"figcaption\""
+              },
+              {
+                "value": "\"figure\""
+              },
+              {
+                "value": "\"footer\""
+              },
+              {
+                "value": "\"form\""
+              },
+              {
+                "value": "\"h1\""
+              },
+              {
+                "value": "\"h2\""
+              },
+              {
+                "value": "\"h3\""
+              },
+              {
+                "value": "\"h4\""
+              },
+              {
+                "value": "\"h5\""
+              },
+              {
+                "value": "\"h6\""
+              },
+              {
+                "value": "\"head\""
+              },
+              {
+                "value": "\"header\""
+              },
+              {
+                "value": "\"hgroup\""
+              },
+              {
+                "value": "\"hr\""
+              },
+              {
+                "value": "\"html\""
+              },
+              {
+                "value": "\"i\""
+              },
+              {
+                "value": "\"iframe\""
+              },
+              {
+                "value": "\"img\""
+              },
+              {
+                "value": "\"input\""
+              },
+              {
+                "value": "\"ins\""
+              },
+              {
+                "value": "\"kbd\""
+              },
+              {
+                "value": "\"label\""
+              },
+              {
+                "value": "\"legend\""
+              },
+              {
+                "value": "\"li\""
+              },
+              {
+                "value": "\"link\""
+              },
+              {
+                "value": "\"main\""
+              },
+              {
+                "value": "\"map\""
+              },
+              {
+                "value": "\"mark\""
+              },
+              {
+                "value": "\"menu\""
+              },
+              {
+                "value": "\"meta\""
+              },
+              {
+                "value": "\"meter\""
+              },
+              {
+                "value": "\"nav\""
+              },
+              {
+                "value": "\"noscript\""
+              },
+              {
+                "value": "\"ol\""
+              },
+              {
+                "value": "\"optgroup\""
+              },
+              {
+                "value": "\"option\""
+              },
+              {
+                "value": "\"output\""
+              },
+              {
+                "value": "\"p\""
+              },
+              {
+                "value": "\"picture\""
+              },
+              {
+                "value": "\"pre\""
+              },
+              {
+                "value": "\"progress\""
+              },
+              {
+                "value": "\"q\""
+              },
+              {
+                "value": "\"rp\""
+              },
+              {
+                "value": "\"rt\""
+              },
+              {
+                "value": "\"ruby\""
+              },
+              {
+                "value": "\"s\""
+              },
+              {
+                "value": "\"samp\""
+              },
+              {
+                "value": "\"script\""
+              },
+              {
+                "value": "\"search\""
+              },
+              {
+                "value": "\"section\""
+              },
+              {
+                "value": "\"select\""
+              },
+              {
+                "value": "\"small\""
+              },
+              {
+                "value": "\"source\""
+              },
+              {
+                "value": "\"span\""
+              },
+              {
+                "value": "\"strong\""
+              },
+              {
+                "value": "\"sub\""
+              },
+              {
+                "value": "\"summary\""
+              },
+              {
+                "value": "\"sup\""
+              },
+              {
+                "value": "\"table\""
+              },
+              {
+                "value": "\"tbody\""
+              },
+              {
+                "value": "\"td\""
+              },
+              {
+                "value": "\"template\""
+              },
+              {
+                "value": "\"textarea\""
+              },
+              {
+                "value": "\"tfoot\""
+              },
+              {
+                "value": "\"th\""
+              },
+              {
+                "value": "\"thead\""
+              },
+              {
+                "value": "\"time\""
+              },
+              {
+                "value": "\"tr\""
+              },
+              {
+                "value": "\"track\""
+              },
+              {
+                "value": "\"u\""
+              },
+              {
+                "value": "\"ul\""
+              },
+              {
+                "value": "\"var\""
+              },
+              {
+                "value": "\"video\""
+              },
+              {
+                "value": "\"wbr\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Sets the components outer HTML tag.\n\n__Note:__ For TypeScript the types of `ref` are bound to the default tag name, if you change it you are responsible to set the respective types yourself."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Grid": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A layout container component used for aligning items with various sizes in a simple grid.\n\n__Note:__ The `Grid` component is only applying grid styles only on the first level of its children. If you want to define a more complex grid, we recommend implementing a standard [CSS grid layout](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_grid_layout).\n\n__Note:__ The `Grid` currently doesn't implement the same wrapping behavior as the `sap.ui.layout.Grid`. To follow UXC guidelines use a different component.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "vSpacing": {
+          "type": {
+            "name": "Height<string | number>"
+          },
+          "required": false,
+          "description": "Vertical spacing between the rows in the Grid. If not specified, then 1rem.",
+          "defaultValue": {
+            "value": "`\"1rem\"`"
+          }
+        },
+        "hSpacing": {
+          "type": {
+            "name": "Width<string | number>"
+          },
+          "required": false,
+          "description": "Horizontal spacing between the content in the Grid. If not specified, then 1rem.",
+          "defaultValue": {
+            "value": "`\"1rem\"`"
+          }
+        },
+        "position": {
+          "type": {
+            "name": "enum",
+            "raw": "GridPosition | \"Left\" | \"Center\" | \"Right\"",
+            "value": [
+              {
+                "value": "\"Left\""
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Right\""
+              },
+              {
+                "value": "\"Left\""
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Right\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Position of the Grid in the window or surrounding container. Possible values are \"Center\", \"Left\" and \"Right\"."
+        },
+        "defaultSpan": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A string type that represents Grid's default span values for very large, large, medium and small screens for the whole Grid.\nAllowed values are separated by space Letters XL, L, M or S followed by number of columns from 1 to 12 that the container has to take, for example: \"L2 M4 S6\", \"M12\", \"s10\" or \"l4 m4\".\nNote that the parameters has to be provided in the order very large, large, medium, small.\n\nYou can override this default span on each child element by setting the prop `data-layout-span`.",
+          "defaultValue": {
+            "value": "`\"XL3 L3 M6 S12\"`"
+          }
+        },
+        "defaultIndent": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines default for the whole Grid numbers of empty columns before the current span begins. It can be defined for very large, large, medium and small screens.\nAllowed values are separated by space Letters XL, L, M or S followed by number of columns from 0 to 12 that the container has to take, for example: \"L2 M4 S6\", \"M11\", \"s10\" or \"l4 m4\".\nNote that the parameters has to be provided in the order very-large, large, medium, small.\n\nYou can override this default indent on each child element by setting the prop `data-layout-indent`.",
+          "defaultValue": {
+            "value": "`\"XL0 L0 M0 S0\"`"
+          }
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Components that are placed into Grid layout."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "MessageBox": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `MessageBox` component provides easier methods to create a `Dialog`, such as standard alerts, confirmation dialogs, or arbitrary message dialogs.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that label the component.\n\n__Note:__ Per default the prop receives the IDs of the header and the content."
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the Message Box should be opened or closed"
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A custom title for the MessageBox. If not present, it will be derived from the `MessageBox` type."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": true,
+          "description": "Defines the content of the `MessageBox`.\n\n**Note:** Although this prop accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design and accessibility capabilities."
+        },
+        "actions": {
+          "type": {
+            "name": "ReactNode[]"
+          },
+          "required": false,
+          "description": "Array of actions of the MessageBox. Those actions will be transformed into buttons in the `MessageBox` footer.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `MessageBoxAction`s (text) or the `Button` component in order to preserve the intended."
+        },
+        "emphasizedAction": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Specifies which action of the created dialog will be emphasized.\n@since 0.16.3",
+          "defaultValue": {
+            "value": "`\"OK\"`"
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "A custom icon. If not present, it will be derived from the `MessageBox` type."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "MessageBoxType | \"Confirm\" | \"Error\" | \"Information\" | \"Success\" | \"Warning\"",
+            "value": [
+              {
+                "value": "\"Confirm\""
+              },
+              {
+                "value": "\"Error\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Success\""
+              },
+              {
+                "value": "\"Warning\""
+              },
+              {
+                "value": "\"Confirm\""
+              },
+              {
+                "value": "\"Error\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Success\""
+              },
+              {
+                "value": "\"Warning\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the type of the `MessageBox` with predefined title, icon, actions and a visual highlight color.",
+          "defaultValue": {
+            "value": "`\"Confirm\"`"
+          }
+        },
+        "initialFocus": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the ID of the HTML Element or the `MessageBoxAction`, which will get the initial focus."
+        },
+        "onClose": {
+          "type": {
+            "name": "(action: string, escPressed?: true) => void"
+          },
+          "required": false,
+          "description": "Callback to be executed when the `MessageBox` is closed (either by pressing on one of the `actions` or by pressing the Escape key).\n`action` is the pressed action button, it's `undefined` when closed via ESC."
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "PopupAccessibleRole | \"None\" | \"Dialog\" | \"AlertDialog\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "Represents no ARIA role."
+              },
+              {
+                "value": "\"Dialog\"",
+                "description": "Represents the ARIA role \"dialog\"."
+              },
+              {
+                "value": "\"AlertDialog\"",
+                "description": "Represents the ARIA role \"alertdialog\"."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Dialog\""
+              },
+              {
+                "value": "\"AlertDialog\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Dialog\""
+          }
+        },
+        "draggable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is draggable.\nIf this property is set to true, the Dialog will be draggable by its header.\n\n**Note:** The component can be draggable only in desktop mode.\n\n**Note:** This property overrides the default HTML \"draggable\" attribute native behavior.\nWhen \"draggable\" is set to true, the native browser \"draggable\"\nbehavior is prevented and only the Dialog custom logic (\"draggable by its header\") works.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "preventFocusRestore": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "preventInitialFocus": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "resizable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Configures the component to be resizable.\nIf this property is set to true, the Dialog will have a resize handle in its bottom right corner in LTR languages.\nIn RTL languages, the resize handle will be placed in the bottom left corner.\n\n**Note:** The component can be resizable only in desktop mode.\n\n**Note:** Upon resizing, externally defined height and width styling will be ignored.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "stretch": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines if the dialog will be stretched to full screen on mobile. On desktop,\nthe dialog will be stretched to approximately 90% of the viewport.\n\n**Note:** For better usability of the component it is recommended to set this property to \"true\" when the dialog is opened on phone.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header HTML Element.\n\n**Note:** When a `Bar` is used in the header, you should remove the default dialog's paddings.\n\n**Note:** If `header` slot is provided, the labelling of the dialog is a responsibility of the application developer.\n`accessibleName` should be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onBeforeClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
+        },
+        "onBeforeOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<DialogDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "MessageItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A component used to hold different types of system messages inside the `MessageView` component.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "titleText": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": true,
+          "description": "Specifies the title of the message\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use text or `Link` (with `wrappingType=\"None\"`) in order to preserve the intended design."
+        },
+        "subtitleText": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "Specifies the subtitle of the message\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design."
+        },
+        "counter": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the number of messages for a given message type."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Specifies the type of the message"
+        },
+        "groupName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Name of a message group the current item belongs to."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Specifies detailed description of the message"
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text alternative of the component.\n\n**Note**: If not provided a default text alternative will be set, if present."
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ListItemCustomDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "MessageView": {
+      "package": "@ui5/webcomponents-react",
+      "description": "\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "length": {
+          "type": {
+            "name": "number"
+          },
+          "required": true,
+          "description": "Gets or sets the length of the array. This is a number one higher than the highest index in the array."
+        },
+        "toString": {
+          "type": {
+            "name": "() => string"
+          },
+          "required": false,
+          "description": "Returns a string representation of an array.",
+          "defaultValue": {}
+        },
+        "toLocaleString": {
+          "type": {
+            "name": "{ (): string; (locales: string | string[], options?: NumberFormatOptions & DateTimeFormatOptions): string; }"
+          },
+          "required": false,
+          "description": "Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.",
+          "defaultValue": {}
+        },
+        "pop": {
+          "type": {
+            "name": "() => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>"
+          },
+          "required": true,
+          "description": "Removes the last element from an array and returns it.\nIf the array is empty, undefined is returned and the array is not modified."
+        },
+        "push": {
+          "type": {
+            "name": "(...items: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]) => number"
+          },
+          "required": true,
+          "description": "Appends new elements to the end of an array, and returns the new length of the array.\n@param items New elements to add to the array."
+        },
+        "concat": {
+          "type": {
+            "name": "{ (...items: ConcatArray<ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>[]): ReactElement<...>[]; (...items: (ReactElement<...> | ConcatArray<...>)[]): ReactElement<...>[]; }"
+          },
+          "required": true,
+          "description": "Combines two or more arrays.\nThis method returns a new array without modifying any existing arrays.\n@param items Additional arrays and/or items to add to the end of the array.\n@param items Additional arrays and/or items to add to the end of the array."
+        },
+        "join": {
+          "type": {
+            "name": "(separator?: string) => string"
+          },
+          "required": true,
+          "description": "Adds all the elements of an array into a string, separated by the specified separator string.\n@param separator A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma."
+        },
+        "reverse": {
+          "type": {
+            "name": "() => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]"
+          },
+          "required": true,
+          "description": "Reverses the elements in an array in place.\nThis method mutates the array and returns a reference to the same array."
+        },
+        "shift": {
+          "type": {
+            "name": "() => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>"
+          },
+          "required": true,
+          "description": "Removes the first element from an array and returns it.\nIf the array is empty, undefined is returned and the array is not modified."
+        },
+        "slice": {
+          "type": {
+            "name": "(start?: number, end?: number) => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]"
+          },
+          "required": true,
+          "description": "Returns a copy of a section of an array.\nFor both start and end, a negative index can be used to indicate an offset from the end of the array.\nFor example, -2 refers to the second to last element of the array.\n@param start The beginning index of the specified portion of the array.\nIf start is undefined, then the slice begins at index 0.\n@param end The end index of the specified portion of the array. This is exclusive of the element at the index 'end'.\nIf end is undefined, then the slice extends to the end of the array."
+        },
+        "sort": {
+          "type": {
+            "name": "(compareFn?: (a: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, b: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>) => number) => ReactElement<...>[]"
+          },
+          "required": true,
+          "description": "Sorts an array in place.\nThis method mutates the array and returns a reference to the same array.\n@param compareFn Function used to determine the order of the elements. It is expected to return\na negative value if the first argument is less than the second argument, zero if they're equal, and a positive\nvalue otherwise. If omitted, the elements are sorted in ascending, ASCII character order.\n```ts\n[11,2,22,1].sort((a, b) => a - b)\n```"
+        },
+        "splice": {
+          "type": {
+            "name": "{ (start: number, deleteCount?: number): ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]; (start: number, deleteCount: number, ...items: ReactElement<...>[]): ReactElement<...>[]; }"
+          },
+          "required": true,
+          "description": "Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.\n@param start The zero-based location in the array from which to start removing elements.\n@param deleteCount The number of elements to remove.\n@returns An array containing the elements that were deleted.\n@param start The zero-based location in the array from which to start removing elements.\n@param deleteCount The number of elements to remove.\n@param items Elements to insert into the array in place of the deleted elements.\n@returns An array containing the elements that were deleted."
+        },
+        "unshift": {
+          "type": {
+            "name": "(...items: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]) => number"
+          },
+          "required": true,
+          "description": "Inserts new elements at the start of an array, and returns the new length of the array.\n@param items Elements to insert at the start of the array."
+        },
+        "indexOf": {
+          "type": {
+            "name": "(searchElement: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, fromIndex?: number) => number"
+          },
+          "required": true,
+          "description": "Returns the index of the first occurrence of a value in an array, or -1 if it is not present.\n@param searchElement The value to locate in the array.\n@param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0."
+        },
+        "lastIndexOf": {
+          "type": {
+            "name": "(searchElement: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, fromIndex?: number) => number"
+          },
+          "required": true,
+          "description": "Returns the index of the last occurrence of a specified value in an array, or -1 if it is not present.\n@param searchElement The value to locate in the array.\n@param fromIndex The array index at which to begin searching backward. If fromIndex is omitted, the search starts at the last index in the array."
+        },
+        "every": {
+          "type": {
+            "name": "{ <S extends ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, index: number, array: ReactElement<...>[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: ReactElement<...>, index: number..."
+          },
+          "required": true,
+          "description": "Determines whether all the members of an array satisfy the specified test.\n@param predicate A function that accepts up to three arguments. The every method calls\nthe predicate function for each element in the array until the predicate returns a value\nwhich is coercible to the Boolean value false, or until the end of the array.\n@param thisArg An object to which the this keyword can refer in the predicate function.\nIf thisArg is omitted, undefined is used as the this value.\n@param predicate A function that accepts up to three arguments. The every method calls\nthe predicate function for each element in the array until the predicate returns a value\nwhich is coercible to the Boolean value false, or until the end of the array.\n@param thisArg An object to which the this keyword can refer in the predicate function.\nIf thisArg is omitted, undefined is used as the this value."
+        },
+        "some": {
+          "type": {
+            "name": "(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, array: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]) => unknown, thisArg?: any) => boolean"
+          },
+          "required": true,
+          "description": "Determines whether the specified callback function returns true for any element of an array.\n@param predicate A function that accepts up to three arguments. The some method calls\nthe predicate function for each element in the array until the predicate returns a value\nwhich is coercible to the Boolean value true, or until the end of the array.\n@param thisArg An object to which the this keyword can refer in the predicate function.\nIf thisArg is omitted, undefined is used as the this value."
+        },
+        "forEach": {
+          "type": {
+            "name": "(callbackfn: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, array: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]) => void, thisArg?: any) => void"
+          },
+          "required": true,
+          "description": "Performs the specified action for each element in an array.\n@param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.\n@param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value."
+        },
+        "map": {
+          "type": {
+            "name": "<U>(callbackfn: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, array: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]) => U, thisArg?: any) => U[]"
+          },
+          "required": true,
+          "description": "Calls a defined callback function on each element of an array, and returns an array that contains the results.\n@param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.\n@param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value."
+        },
+        "filter": {
+          "type": {
+            "name": "{ <S extends ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, index: number, array: ReactElement<...>[]) => value is S, thisArg?: any): S[]; (predicate: (value: ReactElement<...>, index: number, array:..."
+          },
+          "required": true,
+          "description": "Returns the elements of an array that meet the condition specified in a callback function.\n@param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.\n@param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.\n@param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.\n@param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value."
+        },
+        "reduce": {
+          "type": {
+            "name": "{ (callbackfn: (previousValue: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, currentValue: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, currentIndex: number, array: ReactElement<...>[]) => ReactElement<...>): ReactElement<...>; (callbackfn: (previousValue: React..."
+          },
+          "required": true,
+          "description": "Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.\n@param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.\n@param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.\n@param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.\n@param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value."
+        },
+        "reduceRight": {
+          "type": {
+            "name": "{ (callbackfn: (previousValue: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, currentValue: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, currentIndex: number, array: ReactElement<...>[]) => ReactElement<...>): ReactElement<...>; (callbackfn: (previousValue: React..."
+          },
+          "required": true,
+          "description": "Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.\n@param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.\n@param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.\n@param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.\n@param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value."
+        },
+        "find": {
+          "type": {
+            "name": "{ <S extends ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, index: number, obj: ReactElement<...>[]) => value is S, thisArg?: any): S; (predicate: (value: ReactElement<...>, index: number, obj: React..."
+          },
+          "required": true,
+          "description": "Returns the value of the first element in the array where predicate is true, and undefined\notherwise.\n@param predicate find calls predicate once for each element of the array, in ascending\norder, until it finds one where predicate returns true. If such an element is found, find\nimmediately returns that element value. Otherwise, find returns undefined.\n@param thisArg If provided, it will be used as the this value for each invocation of\npredicate. If it is not provided, undefined is used instead."
+        },
+        "findIndex": {
+          "type": {
+            "name": "(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, obj: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]) => unknown, thisArg?: any) => number"
+          },
+          "required": true,
+          "description": "Returns the index of the first element in the array where predicate is true, and -1\notherwise.\n@param predicate find calls predicate once for each element of the array, in ascending\norder, until it finds one where predicate returns true. If such an element is found,\nfindIndex immediately returns that element index. Otherwise, findIndex returns -1.\n@param thisArg If provided, it will be used as the this value for each invocation of\npredicate. If it is not provided, undefined is used instead."
+        },
+        "fill": {
+          "type": {
+            "name": "(value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, start?: number, end?: number) => ReactElement<...>[]"
+          },
+          "required": true,
+          "description": "Changes all array elements from `start` to `end` index to a static `value` and returns the modified array\n@param value value to fill array section with\n@param start index to start filling the array at. If start is negative, it is treated as\nlength+start where length is the length of the array.\n@param end index to stop filling the array at. If end is negative, it is treated as\nlength+end."
+        },
+        "copyWithin": {
+          "type": {
+            "name": "(target: number, start: number, end?: number) => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]"
+          },
+          "required": true,
+          "description": "Returns the this object after copying a section of the array identified by start and end\nto the same array starting at position target\n@param target If target is negative, it is treated as length+target where length is the\nlength of the array.\n@param start If start is negative, it is treated as length+start. If end is negative, it\nis treated as length+end.\n@param end If not specified, length of the this object is used as its default value."
+        },
+        "entries": {
+          "type": {
+            "name": "() => ArrayIterator<[number, ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>]>"
+          },
+          "required": true,
+          "description": "Returns an iterable of key, value pairs for every entry in the array"
+        },
+        "keys": {
+          "type": {
+            "name": "() => ArrayIterator<number>"
+          },
+          "required": true,
+          "description": "Returns an iterable of keys in the array"
+        },
+        "values": {
+          "type": {
+            "name": "() => ArrayIterator<ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>"
+          },
+          "required": true,
+          "description": "Returns an iterable of values in the array"
+        },
+        "includes": {
+          "type": {
+            "name": "(searchElement: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, fromIndex?: number) => boolean"
+          },
+          "required": true,
+          "description": "Determines whether an array includes a certain element, returning true or false as appropriate.\n@param searchElement The element to search for.\n@param fromIndex The position in this array at which to begin searching for searchElement."
+        },
+        "flatMap": {
+          "type": {
+            "name": "<U, This = undefined>(callback: (this: This, value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, array: ReactElement<...>[]) => U | readonly U[], thisArg?: This) => U[]"
+          },
+          "required": true,
+          "description": "Calls a defined callback function on each element of an array. Then, flattens the result into\na new array.\nThis is identical to a map followed by flat with depth 1.\n@param callback A function that accepts up to three arguments. The flatMap method calls the\ncallback function one time for each element in the array.\n@param thisArg An object to which the this keyword can refer in the callback function. If\nthisArg is omitted, undefined is used as the this value."
+        },
+        "flat": {
+          "type": {
+            "name": "<A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]"
+          },
+          "required": true,
+          "description": "Returns a new array with all sub-array elements concatenated into it recursively up to the\nspecified depth.\n@param depth The maximum recursion depth"
+        },
+        "at": {
+          "type": {
+            "name": "(index: number) => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>"
+          },
+          "required": true,
+          "description": "Returns the item located at the specified index.\n@param index The zero-based index of the desired code unit. A negative index will count back from the last item."
+        },
+        "findLast": {
+          "type": {
+            "name": "{ <S extends ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, index: number, array: ReactElement<...>[]) => value is S, thisArg?: any): S; (predicate: (value: ReactElement<...>, index: number, array: R..."
+          },
+          "required": true,
+          "description": "Returns the value of the last element in the array where predicate is true, and undefined\notherwise.\n@param predicate findLast calls predicate once for each element of the array, in descending\norder, until it finds one where predicate returns true. If such an element is found, findLast\nimmediately returns that element value. Otherwise, findLast returns undefined.\n@param thisArg If provided, it will be used as the this value for each invocation of\npredicate. If it is not provided, undefined is used instead."
+        },
+        "findLastIndex": {
+          "type": {
+            "name": "(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, array: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]) => unknown, thisArg?: any) => number"
+          },
+          "required": true,
+          "description": "Returns the index of the last element in the array where predicate is true, and -1\notherwise.\n@param predicate findLastIndex calls predicate once for each element of the array, in descending\norder, until it finds one where predicate returns true. If such an element is found,\nfindLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.\n@param thisArg If provided, it will be used as the this value for each invocation of\npredicate. If it is not provided, undefined is used instead."
+        },
+        "toReversed": {
+          "type": {
+            "name": "() => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]"
+          },
+          "required": true,
+          "description": "Returns a copy of an array with its elements reversed."
+        },
+        "toSorted": {
+          "type": {
+            "name": "(compareFn?: (a: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, b: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>) => number) => ReactElement<...>[]"
+          },
+          "required": true,
+          "description": "Returns a copy of an array with its elements sorted.\n@param compareFn Function used to determine the order of the elements. It is expected to return\na negative value if the first argument is less than the second argument, zero if they're equal, and a positive\nvalue otherwise. If omitted, the elements are sorted in ascending, ASCII character order.\n```ts\n[11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22]\n```"
+        },
+        "toSpliced": {
+          "type": {
+            "name": "{ (start: number, deleteCount: number, ...items: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]): ReactElement<...>[]; (start: number, deleteCount?: number): ReactElement<...>[]; }"
+          },
+          "required": true,
+          "description": "Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array.\nCopies an array and removes elements while returning the remaining elements.\n@param start The zero-based location in the array from which to start removing elements.\n@param deleteCount The number of elements to remove.\n@param items Elements to insert into the copied array in place of the deleted elements.\n@returns The copied array.\n@param start The zero-based location in the array from which to start removing elements.\n@param deleteCount The number of elements to remove.\n@returns A copy of the original array with the remaining elements."
+        },
+        "with": {
+          "type": {
+            "name": "(index: number, value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>) => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]"
+          },
+          "required": true,
+          "description": "Copies an array, then overwrites the value at the provided index with the\ngiven value. If the index is negative, then it replaces from the end\nof the array.\n@param index The index of the value to overwrite. If the index is\nnegative, then it replaces from the end of the array.\n@param value The value to write into the copied array.\n@returns The copied array with the updated value."
+        }
+      },
+      "methods": []
+    },
+    "MessageViewButton": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `MessageViewButton` can be used for opening a `Popover` containing the `MessageView` component. It should always reflect the message `type` with the highest severity.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Specifies the type of the button.\n\n__Note:__ `\"None\"` is displayed as `\"Information\"`.",
+          "defaultValue": {
+            "value": "\"Negative\""
+          }
+        },
+        "counter": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the number of messages for a given message type.\n\n__Note:__ Numbers smaller than 1 are not displayed."
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ButtonAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls, is currently expanded or collapsed.\nAccepts the following string values: `true` or `false`\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n- **ariaLabel**: Defines the accessible ARIA name of the component.\nAccepts any string value.\n\n - **ariaKeyShortcuts**: Defines keyboard shortcuts that activate or give focus to the button.\n\n- **controls**: Identifies the element (or elements) whose contents or presence are controlled by the button element.\nAccepts a lowercase string value.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "ButtonAccessibleRole | \"Button\" | \"Link\"",
+            "value": [
+              {
+                "value": "\"Button\"",
+                "description": "Represents Default (button) ARIA role."
+              },
+              {
+                "value": "\"Link\"",
+                "description": "Represents the ARIA role \"link\"."
+              },
+              {
+                "value": "\"Button\""
+              },
+              {
+                "value": "\"Link\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Describes the accessibility role of the button.\n\n**Note:** Use <code>ButtonAccessibleRole.Link</code> role only with a press handler, which performs a navigation. In all other scenarios the default button semantics are recommended.\n\n**Note:** Available since [v1.23](https://github.com/UI5/webcomponents/releases/tag/v1.23) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Button\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "endIcon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon, displayed as graphical element within the component after the button text.\n\n**Note:** It is highly recommended to use `endIcon` property only together with `icon` and/or `text` properties.\nUsage of `endIcon` only should be avoided.\n\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the button shows a loading indicator.\n\n**Note:** If set to `true`, a busy indicator component will be displayed on the related button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Specifies the delay in milliseconds before the loading indicator appears within the associated button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\n**Note:** A tooltip attribute should be provided for icon-only buttons, in order to represent their exact meaning/function.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
+        },
+        "badge": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Adds a badge to the button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"badge\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<ButtonBadge>`"
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is activated either with a mouse/tap or by using the Enter or Space key.\n\n**Note:** The event will not be fired if the `disabled` property is set to `true`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|"
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ButtonDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Modals": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Utility class for opening modals in an imperative way.\n\nThese static helper methods might be useful for showing e.g. Toasts or MessageBoxes after successful or failed\nnetwork calls.\n\n**In order to use these helpers, please make sure to render the `Modals` component somewhere in your application tree.**\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {},
+      "methods": []
+    },
+    "NumericSideIndicator": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Holds a set of side indicator attributes used in the AnalyticalCardHeader component.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "number": {
+          "type": {
+            "name": "string | number"
+          },
+          "required": true,
+          "description": "The numeric value"
+        },
+        "state": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueColor",
+            "value": [
+              {
+                "value": "\"Critical\"",
+                "description": "Critical value color."
+              },
+              {
+                "value": "\"Error\"",
+                "description": "Error value color."
+              },
+              {
+                "value": "\"Good\"",
+                "description": "Good value color."
+              },
+              {
+                "value": "\"Neutral\"",
+                "description": "Neutral value color."
+              },
+              {
+                "value": "\"None\"",
+                "description": "None value color.\n\n__Note__: \"None\" has the same color as \"Neutral\" but doesn't add the tooltip and accessible-name for the numeric content."
+              }
+            ]
+          },
+          "required": false,
+          "description": "The semantic color which represents the state of the side indicator.",
+          "defaultValue": {
+            "value": "`\"None\"`"
+          }
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": true,
+          "description": "The title of the indicator"
+        },
+        "unit": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the unit of measurement (scaling prefix) for the numeric value"
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ObjectPage": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A component that allows apps to easily display information related to a business object.\n\nThe `ObjectPage` is composed of a header (title and content) and block content wrapped in sections and subsections that structure the information.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "titleArea": {
+          "type": {
+            "name": "ReactElement<ObjectPageTitlePropTypes, string | JSXElementConstructor<any>>"
+          },
+          "required": false,
+          "description": "Defines the upper, always static, title section of the `ObjectPage`.\n\n__Note:__\n- Use the `ObjectPageTitle` component in order to preserve the intended design.\n- When the `ObjectPageTitle` is rendered inside a custom component, it's essential to pass through all props, as otherwise the component won't function as intended!"
+        },
+        "headerArea": {
+          "type": {
+            "name": "ReactElement<ObjectPageHeaderPropTypes, string | JSXElementConstructor<any>>"
+          },
+          "required": false,
+          "description": "Defines the `ObjectPageHeader` section of the `ObjectPage`.\n\n__Note:__\n- Use the `ObjectPageHeader` component in order to preserve the intended design.\n- The `ObjectPageHeader` is essentially the `DynamicPageHeader` recommended by SAP Design. It was renamed in v2 to avoid conflicts with the `DynamicPageHeader` from `@ui5/webcomponents`.\n- When the `ObjectPageHeader` is rendered inside a custom component, it's essential to pass through all props, as otherwise the component won't function as intended!"
+        },
+        "footerArea": {
+          "type": {
+            "name": "ReactElement<unknown, string | JSXElementConstructor<any>>"
+          },
+          "required": false,
+          "description": "React element which defines the footer content.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `Bar` with `design={BarDesign.FloatingFooter}` in order to preserve the intended design."
+        },
+        "image": {
+          "type": {
+            "name": "string | ReactElement<AvatarPropTypes, string | JSXElementConstructor<any>>"
+          },
+          "required": false,
+          "description": "Defines the image of the `ObjectPage`. You can pass a path to an image or an `Avatar` component."
+        },
+        "children": {
+          "type": {
+            "name": "ObjectPageSectionType | ObjectPageSectionType[]"
+          },
+          "required": false,
+          "description": "Defines the content area of the `ObjectPage`. It consists of sections and subsections.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `ObjectPageSection` in order to preserve the intended design."
+        },
+        "selectedSectionId": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Sets the current selected `ObjectPageSection` by `id`.\n\n__Note:__ If a valid `selectedSubSectionId` is set, this prop has no effect."
+        },
+        "selectedSubSectionId": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Sets the current selected `ObjectPageSubSection` by `id`."
+        },
+        "headerPinned": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the `headerArea` is pinned."
+        },
+        "imageShapeCircle": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the image should be displayed in a circle or in a square.<br />\n__Note:__ If the `image` is not a `string`, this prop has no effect."
+        },
+        "mode": {
+          "type": {
+            "name": "enum",
+            "raw": "ObjectPageMode | \"Default\" | \"IconTabBar\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "All `ObjectPageSections` and `ObjectPageSubSections` are displayed on one page.\nSelecting tabs will scroll to the corresponding section."
+              },
+              {
+                "value": "\"IconTabBar\"",
+                "description": "All `ObjectPageSections` are displayed on separate pages.\nSelecting tabs will lead to the corresponding page."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"IconTabBar\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the `ObjectPage` mode.\n\n- \"Default\": All `ObjectPageSections` and `ObjectPageSubSections` are displayed on one page. Selecting tabs will scroll to the corresponding section.\n- \"IconTabBar\": All `ObjectPageSections` are displayed on separate pages. Selecting tabs will lead to the corresponding page.",
+          "defaultValue": {
+            "value": "`\"Default\"`"
+          }
+        },
+        "hidePinButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the pin button for the `headerArea` is hidden."
+        },
+        "preserveHeaderStateOnClick": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the user can switch between the expanded/collapsed states of the `ObjectPageHeader` by clicking on the `ObjectPageTitle`.\n\n__Note:__ Per default the header is toggleable."
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "{ objectPageTopHeader?: { role?: string; ariaRoledescription?: string; }; objectPageAnchorBar?: { expandButton?: { expanded?: boolean | \"true\" | \"false\"; accessibleName?: string; }; role?: string; }; objectPageFooterArea?: { ...; }; }"
+          },
+          "required": false,
+          "description": "Defines internally used accessibility properties/attributes."
+        },
+        "placeholder": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "If set, only the specified placeholder will be displayed as content of the `ObjectPage`, no sections or sub-sections will be rendered.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use placeholder components like the `IllustratedMessage` or custom skeletons pages in order to preserve the intended design."
+        },
+        "onBeforeNavigate": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TabContainerDomRef, ObjectPageTabSelectEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a section is selected via the tab bar, before navigation occurs. To cancel navigation, call `event.preventDefault()` within the event handler.\n\n__Note:__ This event is fired every time a user selects a section, even if the section is already selected."
+        },
+        "onSelectedSectionChange": {
+          "type": {
+            "name": "(event: CustomEvent<{ selectedSectionIndex: number; selectedSectionId: string; section: HTMLDivElement; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when the selected section changes."
+        },
+        "onToggleHeaderArea": {
+          "type": {
+            "name": "(visible: boolean) => void"
+          },
+          "required": false,
+          "description": "Fired when the `headerArea` is expanded or collapsed."
+        },
+        "onPinButtonToggle": {
+          "type": {
+            "name": "(pinned: boolean) => void"
+          },
+          "required": false,
+          "description": "Fired when the `headerArea` changes its pinned state."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ObjectPageDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ObjectPageAnchorBar": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ObjectPageAnchorBar` bar contains the expand/collapse (expands or collapses the header content) and pin button (pins the content header).\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "headerContentVisible": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": true,
+          "description": "Determines if the header content is visible."
+        },
+        "hidePinButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": true,
+          "description": "Defines if the pin button is hidden."
+        },
+        "headerPinned": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines if the header is initially pinned ."
+        },
+        "setHeaderPinned": {
+          "type": {
+            "name": "Dispatch<SetStateAction<boolean>>"
+          },
+          "required": false,
+          "description": "Set the header to the state pinned."
+        },
+        "onToggleHeaderContentVisibility": {
+          "type": {
+            "name": "(e: any) => void"
+          },
+          "required": true,
+          "description": "Toggles the header content to be hidden or visible ."
+        },
+        "onHoverToggleButton": {
+          "type": {
+            "name": "(e: MouseEvent<ToggleButtonDomRef, MouseEvent>) => void"
+          },
+          "required": false,
+          "description": "Highlight title when hovered."
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "{ expandButton?: { expanded?: boolean | \"true\" | \"false\"; accessibleName?: string; }; role?: string; }"
+          },
+          "required": false,
+          "description": "Defines internally used accessibility properties/attributes."
+        },
+        "onPinButtonToggle": {
+          "type": {
+            "name": "(pinned: boolean) => void"
+          },
+          "required": false,
+          "description": "Fired when the `headerContent` changes its pinned state."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ObjectPageHeader": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ObjectPageHeader` component is used to serve as header section of the `ObjectPage`. It can hold any layout control and has two states - expanded and collapsed.\n\n__Note:__\n- When used inside a custom component, it's essential to pass through all props, as otherwise the component won't function as intended!\n- The `ObjectPageHeader` is essentially the `DynamicPageHeader` recommended by SAP Design. It was renamed in v2 to avoid conflicts with the `DynamicPageHeader` from `@ui5/webcomponents`.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "headerPinned": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines if the header is pinned."
+        },
+        "topHeaderHeight": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Determines the height of the top header (`ObjectPageTitle`)."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Content of the `ObjectPageHeader`."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ObjectPageSection": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Top-level information container of an `ObjectPage`.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "id": {
+          "type": {
+            "name": "string"
+          },
+          "required": true,
+          "description": "Defines the ID of the `ObjectPageSection`.\n\n__Note:__ The `id` is taken into account when the section selection changes."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": true,
+          "description": "Defines the content of the `ObjectPageSection`.\n\n__Note:__ Only use subsections if more than one is available. Otherwise, add the content of the section directly as `child`."
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": true,
+          "description": "Defines the title of the `ObjectPageSection`."
+        },
+        "titleTextUppercase": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the title is always displayed in uppercase."
+        },
+        "hideTitleText": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether to display the Section title or not."
+        },
+        "titleTextLevel": {
+          "type": {
+            "name": "enum",
+            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
+            "value": [
+              {
+                "value": "\"H1\"",
+                "description": "Renders `h1` tag."
+              },
+              {
+                "value": "\"H2\"",
+                "description": "Renders `h2` tag."
+              },
+              {
+                "value": "\"H3\"",
+                "description": "Renders `h3` tag."
+              },
+              {
+                "value": "\"H4\"",
+                "description": "Renders `h4` tag."
+              },
+              {
+                "value": "\"H5\"",
+                "description": "Renders `h5` tag."
+              },
+              {
+                "value": "\"H6\"",
+                "description": "Renders `h6` tag."
+              },
+              {
+                "value": "\"H1\""
+              },
+              {
+                "value": "\"H2\""
+              },
+              {
+                "value": "\"H3\""
+              },
+              {
+                "value": "\"H4\""
+              },
+              {
+                "value": "\"H5\""
+              },
+              {
+                "value": "\"H6\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the ARIA level of the ObjectPageSection `titleText`. The ARIA level is used by assisting technologies, such as screen readers, to create a hierarchical site map for faster navigation.\n\n__Note:__ Defining a `titleTextLevel` will add aria-level attribute from 1 to 6, instead of changing the ObjectPageSectionBase title HTML tag from H1 to H6.\nFor example: if titleTextLevel is TitleLevel.H1, it will result as aria-level of 1 added to the ObjectPageSection title.",
+          "defaultValue": {
+            "value": "TitleLevel.H3"
+          }
+        },
+        "wrapTitleText": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the Section title wraps on multiple lines, when the available space is not enough."
+        },
+        "header": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "Section header content.\n\n__Note__: Although this prop accepts all HTML Elements, it is strongly recommended that you only use non-focusable elements to preserve the intended design."
+        },
+        "tabRef": {
+          "type": {
+            "name": "Ref<TabDomRef>"
+          },
+          "required": false,
+          "description": "This ref will be attached to the underlying `ui5-tab` DOM element,\nallowing direct access to its instance methods and properties (e.g. `getDomRefInStrip`)."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ObjectPageSubSection": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Second-level information container of an `ObjectPage`.\n\n__Note:__ This component should only be used inside an `ObjectPageSection` component.\n\n__Note:__ Only use subsections if more than one is available. Otherwise, add the content of the section directly as `child` of the `ObjectPageSection`.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "id": {
+          "type": {
+            "name": "string"
+          },
+          "required": true,
+          "description": "Defines the ID of the `ObjectPageSubSection`."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": true,
+          "description": "Defines the content of the `ObjectPageSubSection`."
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": true,
+          "description": "Defines the title of the `ObjectPageSubSection`."
+        },
+        "actions": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Actions available for this subsection.\n\n__Note:__ Keep in mind that the components set in the actions prop do NOT have overflow behavior. If the available space is not enough, the components will be displayed on more lines.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use simple input components like `Button` or `Switch` to preserve the intended design."
+        },
+        "hideTitleText": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether to display the SubSection `titleText` or not."
+        },
+        "titleTextLevel": {
+          "type": {
+            "name": "enum",
+            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
+            "value": [
+              {
+                "value": "\"H1\"",
+                "description": "Renders `h1` tag."
+              },
+              {
+                "value": "\"H2\"",
+                "description": "Renders `h2` tag."
+              },
+              {
+                "value": "\"H3\"",
+                "description": "Renders `h3` tag."
+              },
+              {
+                "value": "\"H4\"",
+                "description": "Renders `h4` tag."
+              },
+              {
+                "value": "\"H5\"",
+                "description": "Renders `h5` tag."
+              },
+              {
+                "value": "\"H6\"",
+                "description": "Renders `h6` tag."
+              },
+              {
+                "value": "\"H1\""
+              },
+              {
+                "value": "\"H2\""
+              },
+              {
+                "value": "\"H3\""
+              },
+              {
+                "value": "\"H4\""
+              },
+              {
+                "value": "\"H5\""
+              },
+              {
+                "value": "\"H6\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the ARIA level of the ObjectPageSubSection `titleText`. The ARIA level is used by assisting technologies, such as screen readers, to create a hierarchical site map for faster navigation.\n\n__Note:__ Defining a `titleTextLevel` will add aria-level attribute from 1 to 6, instead of changing the ObjectPageSectionBase title HTML tag from H1 to H6.\nFor example: if titleTextLevel is TitleLevel.H1, it will result as aria-level of 1 added to the ObjectPageSection title.",
+          "defaultValue": {
+            "value": "TittleLevel.H4"
+          }
+        },
+        "titleTextUppercase": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the title is always displayed in uppercase."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ObjectPageTitle": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ObjectPageTitle` component is used to serve as title of the `ObjectPage`.\nIt can contain Breadcrumbs, Title, Subtitle, Content, KPIs and Actions.\n\n__Note:__ When used inside a custom component, it's essential to pass through all props, as otherwise the component won't function as intended!\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "actionsBar": {
+          "type": {
+            "name": "ReactElement<unknown, string | JSXElementConstructor<any>>"
+          },
+          "required": false,
+          "description": "Defines the actions bar of the `ObjectPageTitle`.\n\n__Note:__ Although this prop accepts all `ReactElement`s, it is strongly recommended that you only use the `Toolbar` component in order to preserve the intended design."
+        },
+        "breadcrumbs": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "The `breadcrumbs` displayed in the `ObjectPageTitle` top-left area.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `Breadcrumbs` in order to preserve the intended design."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "The content is positioned in the `ObjectPageTitle` middle area"
+        },
+        "header": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "The `header` is displayed in the left area of the `ObjectPageTitle`.\nUse this prop to render a `Title` or any other component that serves as a heading.\n\n__Note:__ If the header is snapped (collapsed), the `snappedHeader` prop is used instead (if defined)."
+        },
+        "snappedHeader": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "The `snappedHeader` is displayed in the left area of the `ObjectPageTitle` when the header is snapped (collapsed).\nUse this prop to render a `Title` or any other component that serves as a heading in the snapped view.\n@since 2.12.0"
+        },
+        "subHeader": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "The `subHeader` is displayed in the left area of the `ObjectPageTitle`, below the `header`.\nUse this prop to render a `Label` or any other component that serves as a sub-header.\n\n__Note:__ If the header is snapped (collapsed), the `snappedSubHeader` prop is used instead (if defined)."
+        },
+        "snappedSubHeader": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "The `snappedSubHeader` is displayed in the left area of the `ObjectPageTitle` when the header is snapped (collapsed).\nUse this prop to render a `Label` or any other component that serves as a sub-header in the snapped view.\n@since 2.12.0"
+        },
+        "navigationBar": {
+          "type": {
+            "name": "ReactElement<unknown, string | JSXElementConstructor<any>>"
+          },
+          "required": false,
+          "description": "Defines navigation-actions bar of the `ObjectPageTitle`.\n\n*Note*: The `navigationBar` position depends on the control size.\nIf the control size is 1280px or bigger, they are rendered right next to the `actionsBar`.\nOtherwise, they are rendered in the top-right area (above the `actionsBar`).\nIf a large number of elements(buttons) are used, there could be visual degradations as the space for the `navigationBar` is limited.\n\n__Note:__ Although this prop accepts all `ReactElement`s, it is strongly recommended that you only use the `Toolbar` component in order to preserve the intended design."
+        },
+        "expandedContent": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "The content displayed in the `ObjectPageTitle` in expanded state."
+        },
+        "snappedContent": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "The content displayed in the `ObjectPageTitle` in collapsed (snapped) state."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ObjectStatus": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Status information that can be either text with a value state, or an icon.\n\n__Note:__ When used in interactive lists or tables, consider overriding the active state styling. Learn more [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/data-display-objectstatus--docs#objectstatus-in-interactive-lists-or-tables).\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "interactive": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if the ObjectStatus is rendered as inactive `div` or interactive `button` and therefore can be clicked/tapped by the user or not.\n\n**Note:** If this prop is set to `true`, you should also set the `children` or `icon` prop.\n@since 0.16.6"
+        },
+        "icon": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "Defines the icon in front of the `ObjectStatus` text.\n\n__Note:__ Although this slot accepts HTML Elements, it is strongly recommended that you only use the `Icon` component with `mode=\"Decorative\"` in order to preserve the intended design."
+        },
+        "inverted": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the background color reflects the set state instead of the text\n@since 0.16.6"
+        },
+        "large": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the component should be rendered in large design.\n@since 1.21.0"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode"
+          },
+          "required": false,
+          "description": "Defines the text of the `ObjectStatus`.\n\n__Note:__ Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design."
+        },
+        "state": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\" | IndicationColor | \"Indication01\" | \"Indication02\" | \"Indication03\" | ... 16 more ... | \"Indication20\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Indication01\"",
+                "description": "Dark Red"
+              },
+              {
+                "value": "\"Indication02\"",
+                "description": "Red"
+              },
+              {
+                "value": "\"Indication03\"",
+                "description": "Yellow"
+              },
+              {
+                "value": "\"Indication04\"",
+                "description": "Green"
+              },
+              {
+                "value": "\"Indication05\"",
+                "description": "Blue"
+              },
+              {
+                "value": "\"Indication06\"",
+                "description": "Teal"
+              },
+              {
+                "value": "\"Indication07\"",
+                "description": "Purple"
+              },
+              {
+                "value": "\"Indication08\"",
+                "description": "Pink"
+              },
+              {
+                "value": "\"Indication09\"",
+                "description": "Black/White"
+              },
+              {
+                "value": "\"Indication10\"",
+                "description": "Grey"
+              },
+              {
+                "value": "\"Indication11\"",
+                "description": "Dark Red (second color set)"
+              },
+              {
+                "value": "\"Indication12\"",
+                "description": "Red (second color set)"
+              },
+              {
+                "value": "\"Indication13\"",
+                "description": "Yellow (second color set)"
+              },
+              {
+                "value": "\"Indication14\"",
+                "description": "Green (second color set)"
+              },
+              {
+                "value": "\"Indication15\"",
+                "description": "Blue (second color set)"
+              },
+              {
+                "value": "\"Indication16\"",
+                "description": "Teal (second color set)"
+              },
+              {
+                "value": "\"Indication17\"",
+                "description": "Purple (second color set)"
+              },
+              {
+                "value": "\"Indication18\"",
+                "description": "Pink (second color set)"
+              },
+              {
+                "value": "\"Indication19\"",
+                "description": "Black/White (second color set)"
+              },
+              {
+                "value": "\"Indication20\"",
+                "description": "Grey (second color set)"
+              },
+              {
+                "value": "\"Indication01\""
+              },
+              {
+                "value": "\"Indication02\""
+              },
+              {
+                "value": "\"Indication03\""
+              },
+              {
+                "value": "\"Indication04\""
+              },
+              {
+                "value": "\"Indication05\""
+              },
+              {
+                "value": "\"Indication06\""
+              },
+              {
+                "value": "\"Indication07\""
+              },
+              {
+                "value": "\"Indication08\""
+              },
+              {
+                "value": "\"Indication09\""
+              },
+              {
+                "value": "\"Indication10\""
+              },
+              {
+                "value": "\"Indication11\""
+              },
+              {
+                "value": "\"Indication12\""
+              },
+              {
+                "value": "\"Indication13\""
+              },
+              {
+                "value": "\"Indication14\""
+              },
+              {
+                "value": "\"Indication15\""
+              },
+              {
+                "value": "\"Indication16\""
+              },
+              {
+                "value": "\"Indication17\""
+              },
+              {
+                "value": "\"Indication18\""
+              },
+              {
+                "value": "\"Indication19\""
+              },
+              {
+                "value": "\"Indication20\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the `ObjectStatus`.\n\nSince version 0.17.0 the state property also accepts values from enum `IndicationColor`.\n\n__Note:__ Only the `inverted` `ObjectStatus` supports `IndicationColor`s 11-20. For non-inverted `ObjectStatus`, these colors default to the `\"None\"` `state` color and should __not__ be used.",
+          "defaultValue": {
+            "value": "`\"None\"`"
+          }
+        },
+        "showDefaultIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the default icon for each `ValueState` should be displayed.\n\n__Note:__ If the `icon` prop was set, `showDefaultIcon` has no effect."
+        },
+        "emptyIndicator": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Specifies if an empty indicator should be displayed when there is no text.\n@since 1.19.0"
+        },
+        "stateAnnouncementText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Enables overriding of the default state announcement read by screen readers.\n@since 1.19.0"
+        },
+        "onClick": {
+          "type": {
+            "name": "MouseEventHandler<HTMLButtonElement>"
+          },
+          "required": false,
+          "description": "Fires when the user clicks/taps on an interactive text.\n\n__Note:__ This prop has no effect if `interactive` is not set to `true`.\n@since 0.16.6"
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement | HTMLButtonElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ResponsiveGridLayout": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The Responsive Grid Layout positions UI elements in a multi-column flow layout.\nThey can be configured to display a variable number of columns depending on available screen size.\nWith these controls, it is possible to achieve flexible layouts and line breaks for large, medium,\nand small-sized screens, such as desktop, tablet, and mobile.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "columnsS": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Number of columns to show on small screens (`max-width: 599px`)"
+        },
+        "columnsM": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Number of columns to show on medium screens (`width >= 600px and width <=1023px`)"
+        },
+        "columnsL": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Number of columns to show on large screens (`width >= 1024px and width <=1439px`)"
+        },
+        "columnsXL": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Number of columns to show on extra large screens (`min-width: 1440px`)"
+        },
+        "columnSpanS": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines how many columns a single child should cover on small screens."
+        },
+        "columnSpanM": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines how many columns a single child should cover on medium screens."
+        },
+        "columnSpanL": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines how many columns a single child should cover on large screens."
+        },
+        "columnSpanXL": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines how many columns a single child should cover on extra large."
+        },
+        "columnGap": {
+          "type": {
+            "name": "enum",
+            "raw": "\"0.5rem\" | \"1rem\"",
+            "value": [
+              {
+                "value": "\"0.5rem\""
+              },
+              {
+                "value": "\"1rem\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Gap between two columns of the grid"
+        },
+        "rowGap": {
+          "type": {
+            "name": "enum",
+            "raw": "\"0.5rem\" | \"1rem\"",
+            "value": [
+              {
+                "value": "\"0.5rem\""
+              },
+              {
+                "value": "\"1rem\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Gap between two rows of the grid"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Child elements to be placed inside the grid. In case you want to control the column span of each child independently,\nyou can add an element style using the [gridColumn shorthand](https://developer.mozilla.org/en-US/docs/Web/CSS/grid-column).\n\nExample: If you want one child to span across 4 columns, you can add this element style to the child element:\n`style={{ gridColumn: 'span 4' }}`"
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SelectDialog": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The SelectDialog enables users to filter a comprehensive list via a search field and to select one or more items.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component.\n\n__Note:__ If not set, the dialog uses the `headerText` for its accessible name."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the list items of the component.\n\n__Note:__ Although this prop accepts all HTML Elements and therefore also all list items, it is strongly recommended that you only use `ListItemStandard` in order to preserve the intended design."
+        },
+        "showClearButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "This flag controls whether the Clear button is shown. When set to `true`, it provides a way to clear selections. We recommend enabling the Clear button in cases where a mechanism to delete the selection is required: In single selection mode (default mode) or when `rememberSelections` is set to `true`."
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text."
+        },
+        "headerTextAlignCenter": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Specifies the `headerText` alignment."
+        },
+        "headerTextLevel": {
+          "type": {
+            "name": "enum",
+            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
+            "value": [
+              {
+                "value": "\"H1\"",
+                "description": "Renders `h1` tag."
+              },
+              {
+                "value": "\"H2\"",
+                "description": "Renders `h2` tag."
+              },
+              {
+                "value": "\"H3\"",
+                "description": "Renders `h3` tag."
+              },
+              {
+                "value": "\"H4\"",
+                "description": "Renders `h4` tag."
+              },
+              {
+                "value": "\"H5\"",
+                "description": "Renders `h5` tag."
+              },
+              {
+                "value": "\"H6\"",
+                "description": "Renders `h6` tag."
+              },
+              {
+                "value": "\"H1\""
+              },
+              {
+                "value": "\"H2\""
+              },
+              {
+                "value": "\"H3\""
+              },
+              {
+                "value": "\"H4\""
+              },
+              {
+                "value": "\"H5\""
+              },
+              {
+                "value": "\"H6\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the aria-level of the `headerText`.\nAvailable options are: `\"H1\"` to `\"H6\"`.\nThis property does not influence the style of the `headerText`.",
+          "defaultValue": {
+            "value": "\"H1\""
+          }
+        },
+        "confirmButtonText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Overwrites the default text for the confirmation button."
+        },
+        "rememberSelections": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "This flag controls whether the dialog clears the selection after the confirm event has been fired. If the dialog needs to be opened multiple times in the same context to allow for corrections of previous user inputs, set this flag to `true`.\n\n__Note:__ This won't work if the dialog is unmounted, if you want to unmount the dialog when closed, you need to persist the selection yourself."
+        },
+        "numberOfSelectedItems": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the number of selected list items displayed above the list in `MultiSelect` mode. Programmatically setting the counter is necessary if all previously selected elements are to remain selected during search."
+        },
+        "selectionMode": {
+          "type": {
+            "name": "enum",
+            "raw": "ListSelectionMode | \"None\" | \"Single\" | \"SingleStart\" | \"SingleEnd\" | \"SingleAuto\" | \"Multiple\" | \"Delete\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "Default mode (no selection)."
+              },
+              {
+                "value": "\"Single\"",
+                "description": "Right-positioned single selection mode (only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleStart\"",
+                "description": "Left-positioned single selection mode (only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleEnd\"",
+                "description": "Selected item is highlighted but no selection element is visible\n(only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleAuto\"",
+                "description": "Selected item is highlighted and selection is changed upon arrow navigation\n(only one list item can be selected - this is always the focused item)."
+              },
+              {
+                "value": "\"Multiple\"",
+                "description": "Multi selection mode (more than one list item can be selected)."
+              },
+              {
+                "value": "\"Delete\"",
+                "description": "Delete mode (only one list item can be deleted via provided delete button)"
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Single\""
+              },
+              {
+                "value": "\"SingleStart\""
+              },
+              {
+                "value": "\"SingleEnd\""
+              },
+              {
+                "value": "\"SingleAuto\""
+              },
+              {
+                "value": "\"Multiple\""
+              },
+              {
+                "value": "\"Delete\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the mode of the SelectDialog list.\n\n__Note:__ Although this prop accepts all `ListSelectionMode`s, it is strongly recommended that you only use `Single` or `Multiple` in order to preserve the intended design.",
+          "defaultValue": {
+            "value": "ListSelectionMode.Single"
+          }
+        },
+        "listProps": {
+          "type": {
+            "name": "Omit<ListPropTypes, \"children\" | \"growing\" | \"onLoadMore\" | \"footerText\" | \"selectionMode\">"
+          },
+          "required": false,
+          "description": "Defines props you can pass to the internal `List` component.\n\n__Note:__ `selectionMode`, `children`, `growing`, `onLoadMore` and `footerText` are not supported.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "confirmButtonProps": {
+          "type": {
+            "name": "Omit<ButtonPropTypes, \"onClick\" | \"design\">"
+          },
+          "required": false,
+          "description": "Defines the props of the confirm button.\n\n__Note:__`onClick` and `design` are not supported.\n@since 1.25.0"
+        },
+        "onSearchInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, { value: string; }>) => void"
+          },
+          "required": false,
+          "description": "This event will be fired when the value of the search field is changed by a user - e.g. at each key press"
+        },
+        "onSearch": {
+          "type": {
+            "name": "((event: Ui5CustomEvent<InputDomRef, { value: string; }>) => void) | ((event: Ui5CustomEvent<IconDomRef, { value: string; }>) => void)"
+          },
+          "required": false,
+          "description": "This event will be fired when the search button has been clicked or the ENTER key has been pressed in the search field."
+        },
+        "onSearchReset": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<{ prevValue: string; nativeDetail?: number; }, never>) => void"
+          },
+          "required": false,
+          "description": "This event will be fired when the reset button has been clicked in the search field or when the dialog is closed."
+        },
+        "onClear": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ButtonDomRef, { prevSelectedItems: ListItemStandardDomRef[]; nativeDetail: number; }>) => void"
+          },
+          "required": false,
+          "description": "This event will be fired when the clear button has been clicked."
+        },
+        "onConfirm": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ButtonDomRef | ListDomRef, { selectedItems: ListItemBase[]; }>) => void"
+          },
+          "required": false,
+          "description": "This event will be fired when the dialog is confirmed by selecting an item in single selection mode or by pressing the confirmation button in multi selection mode."
+        },
+        "onCancel": {
+          "type": {
+            "name": "((event: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail>) => void) | ((event: Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) => void)"
+          },
+          "required": false,
+          "description": "This event will be fired when the cancel button is clicked or ESC key is pressed."
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | PopupAccessibleRole | \"Dialog\" | \"AlertDialog\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\"",
+                "description": "Represents no ARIA role."
+              },
+              {
+                "value": "\"Dialog\"",
+                "description": "Represents the ARIA role \"dialog\"."
+              },
+              {
+                "value": "\"AlertDialog\"",
+                "description": "Represents the ARIA role \"alertdialog\"."
+              },
+              {
+                "value": "\"Dialog\""
+              },
+              {
+                "value": "\"AlertDialog\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Dialog\""
+          }
+        },
+        "draggable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is draggable.\nIf this property is set to true, the Dialog will be draggable by its header.\n\n**Note:** The component can be draggable only in desktop mode.\n\n**Note:** This property overrides the default HTML \"draggable\" attribute native behavior.\nWhen \"draggable\" is set to true, the native browser \"draggable\"\nbehavior is prevented and only the Dialog custom logic (\"draggable by its header\") works.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "initialFocus": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the ID of the HTML Element, which will get the initial focus.\n\n**Note:** If an element with `autofocus` attribute is added inside the component,\n`initialFocus` won't take effect."
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if the element is open\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "preventFocusRestore": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "preventInitialFocus": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "resizable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Configures the component to be resizable.\nIf this property is set to true, the Dialog will have a resize handle in its bottom right corner in LTR languages.\nIn RTL languages, the resize handle will be placed in the bottom left corner.\n\n**Note:** The component can be resizable only in desktop mode.\n\n**Note:** Upon resizing, externally defined height and width styling will be ignored.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "stretch": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines if the dialog will be stretched to full screen on mobile. On desktop,\nthe dialog will be stretched to approximately 90% of the viewport.\n\n**Note:** For better usability of the component it is recommended to set this property to \"true\" when the dialog is opened on phone.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "onBeforeClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
+        },
+        "onBeforeOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "growing": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | ListGrowingMode | \"Button\" | \"Scroll\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Button\"",
+                "description": "Component's \"load-more\" is fired upon pressing a \"More\" button.\nat the bottom."
+              },
+              {
+                "value": "\"Scroll\"",
+                "description": "Component's \"load-more\" is fired upon scroll."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Component's growing is not enabled."
+              },
+              {
+                "value": "\"Button\""
+              },
+              {
+                "value": "\"Scroll\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines whether the component will have growing capability either by pressing a `More` button,\nor via user scroll. In both cases `load-more` event is fired.\n\n**Restrictions:** `growing=\"Scroll\"` is not supported for Internet Explorer,\non IE the component will fallback to `growing=\"Button\"`.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "onLoadMore": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user scrolls to the bottom of the list.\n\n**Note:** The event is fired when the `growing='Scroll'` property is enabled.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|"
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<DialogDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Splitter": {
+      "package": "@ui5/webcomponents-react",
+      "description": "\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "height": {
+          "type": {
+            "name": "string | number"
+          },
+          "required": true,
+          "description": ""
+        },
+        "width": {
+          "type": {
+            "name": "string | number"
+          },
+          "required": true,
+          "description": ""
+        },
+        "vertical": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": true,
+          "description": ""
+        },
+        "onResize": {
+          "type": {
+            "name": "(e: OnResizeParam) => void"
+          },
+          "required": true,
+          "description": ""
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SplitterElement": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `SplitterElement` holds the component of the content area. Allowed size values are of the type css property width or\nheight according to the orientation of the `SplitterLayout`. If `size` isn't passed to the element, the width or\nheight of the content area will be calculated automatically according to the size of the given `SplitterLayout`.\nThe `minSize` defines the minimum width or height of the area and is set to 0 when no minimum size is given, so the\ncontent can be completely collapsed.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "resizable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether a resizer element is displayed.\n\nIf the next `SplitterElement` has the prop `resizable={false}`, no resizer element will be shown after this\n`SplitterElement`. The resizer element is only shown when all siblings of the resizer are resizable.\nDefault value of resizable is `true`."
+        },
+        "size": {
+          "type": {
+            "name": "string | number | (string & {})"
+          },
+          "required": false,
+          "description": "Defines the initial size of the `SplitterElement`.\n\n__Note:__ In order to preserve the intended design, at least one `SplitterElement` should have a dynamic `size`.",
+          "defaultValue": {
+            "value": "`\"auto\"`"
+          }
+        },
+        "minSize": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the minimum size of the `SplitterElement`. The resizer element stops when the minimum size is reached.",
+          "defaultValue": {
+            "value": "`0`"
+          }
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content which is shown inside the `SplitterElement`."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SplitterLayout": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A layout that contains several content areas. The content that is added to the `SplitterLayout` should be wrapped\ninto 0-n `SplitterElement`s which define the size and size constraints of the content area.\nThe orientation of the `SplitterLayout` can be set to horizontal (default) or vertical. All content areas of the\nlayout will be arranged in that way. In order to split vertically and horizontally at the same time, splitters need\nto be nested.\nBy adding or changing `SplitterElement`s to the `SplitterLayout` that make up the content areas, the size can be changed\nprogrammatically. Additionally, the content areas can be made non-resizable individually and a minimal size (in px)\ncan be set.\nThe splitter bars are focusable to enable resizing of the content areas via keyboard. The size of the content areas\ncan be manipulated when the splitter bar is focused and Left/Down/Right/Up are pressed.\n\n__Note:__ In order to preserve the intended design, at least one `SplitterElement` should have a dynamic `size`.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "vertical": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Controls if a vertical or horizontal `SplitterLayout` is rendered."
+        },
+        "children": {
+          "type": {
+            "name": "SplitterLayoutChild | SplitterLayoutChild[]"
+          },
+          "required": false,
+          "description": "The content areas (optional) to be split. The control will show n-1 splitter bars between n controls in this aggregation."
+        },
+        "options": {
+          "type": {
+            "name": "SplitterLayoutOptions"
+          },
+          "required": false,
+          "description": "Defines options to customize the behavior of the SplitterLayout."
+        },
+        "onResize": {
+          "type": {
+            "name": "(e: OnResizeParam) => void"
+          },
+          "required": false,
+          "description": "Fired when contents are resized.\n\n__Note:__\n- Resize events can fire many times in quick succession, it’s therefore strongly recommended to debounce your handler if you’re updating React state or causing other expensive operations.\n- The `areas` array reflects the logical position of the `SplitterElement`s relative to the \"Splitter\"."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ThemeProvider": {
+      "package": "@ui5/webcomponents-react",
+      "description": "In order to use `@ui5/webcomponents-react` you have to wrap your application's root component into the ThemeProvider.\n\n__Note:__ Per default, the `ThemeProvider` injects the CSS for the components during runtime. If you have imported our static CSS bundle/s in your application, you can set the prop `staticCssInjected` to `true` to prevent this.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "staticCssInjected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "You can set this flag to true in case you have imported our static CSS Bundle/s in your application.\nThis will prevent the ThemeProvider from injecting the CSS during runtime again.\n\n* __main:__ `import '@ui5/webcomponents-react/styles.css'`\n* __charts:__ `import '@ui5/webcomponents-react-charts/styles.css'`"
+        }
+      },
+      "methods": []
+    },
+    "VariantItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `VariantItem` describes a variant/view of the `VariantManagement` component.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "string"
+          },
+          "required": true,
+          "description": "The name of the variant.\n\n__Note:__ Variant names must be unique."
+        },
+        "author": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Author of the variant."
+        },
+        "favorite": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if favorites can be created.\n\n__Note:__ Has no effect if `showOnlyFavorites` is falsy in the `VariantMangament`."
+        },
+        "global": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicator if a variant is visible for all users (public flag is set)."
+        },
+        "isDefault": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicator if it's the default variant.\n\n__Note:__ There should only be __one__ default variant."
+        },
+        "labelReadOnly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if the variant title can be changed."
+        },
+        "applyAutomatically": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if the variant should be applied automatically on selection."
+        },
+        "applyAutomaticallyText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Text displayed next to the \"Apply Automatically\" checkbox inside the \"Manage Views\" dialog."
+        },
+        "readOnly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "If set to false, the user is allowed to change the item's data.\n\n__Note:__ When set to true, no \"Save\" button will be displayed for the `VariantItem` when the `VariantManagement` is in `dirtyState`."
+        },
+        "hideDelete": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if the variant can be deleted.\n\n__Note:__ If not set, a delete button is shown for all variants except for variants with `global={true}`."
+        },
+        "manageViewsInputProps": {
+          "type": {
+            "name": "Omit<InputPropTypes, \"value\">"
+          },
+          "required": false,
+          "description": "Defines the props of the input rendered with the `VariantItem` inside the \"Manage Views\" dialog.\n\n__Note:__ It is possible to overwrite internally used props. Please use with caution!"
+        },
+        "saveViewInputProps": {
+          "type": {
+            "name": "Omit<InputPropTypes, \"id\" | \"value\">"
+          },
+          "required": false,
+          "description": "Defines the props of the input rendered with the `VariantItem` inside the \"Save View\" dialog.\n\n__Note:__ It is possible to overwrite internally used props. Please use with caution!"
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text alternative of the component.\nNote: If not provided a default text alternative will be set, if present."
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ListItemStandardDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "VariantManagement": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The VariantManagement can be used to manage variants (views). You can use this component to create and maintain personalization changes.\n\n__Note:__ On the user interface, variants are generally referred to as \"views\".\n\n__Note:__ Each `VariantManagement` component can only have one default and one selected variant.\n\n__Note:__  You have to install `@ui5/webcomponents-fiori` to use this component.\n\n### Matching header styles\n\nTo ensure consistent header styles for different use-cases of the `VariantManagement`, we recommend setting the following styles to the `ui5-title` component:\n\n#### DynamicPage & ObjectPage\n\n- `font-family: var(--sapObjectHeader_Title_FontFamily);`\n\n__Header expanded__\n\n- `font-size: var(--sapObjectHeader_Title_FontSize);`\n\n__Header collapsed/snapped__\n\n- `font-size: var(--sapObjectHeader_Title_SnappedFontSize);`\n\n#### Tables\n\n- `font-size: var(--sapGroup_Title_FontSize);`\n\n#### Example\n\n```css\n.variantManagement [data-component-name=\"VariantManagementTitle\"] {\n    font-family: var(--sapObjectHeader_Title_FontFamily);\n    font-size: var(--sapObjectHeader_Title_FontSize);\n}\n```\n```jsx\n <VariantManagement className=\"variantManagement\">\n```\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Variant items displayed by the VariantManagement component.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `VariantItem` in order to preserve the intended design."
+        },
+        "placement": {
+          "type": {
+            "name": "enum",
+            "raw": "PopoverPlacement | \"Start\" | \"End\" | \"Top\" | \"Bottom\"",
+            "value": [
+              {
+                "value": "\"Start\"",
+                "description": "Popover will be placed at the start of the reference element."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Popover will be placed at the end of the reference element."
+              },
+              {
+                "value": "\"Top\"",
+                "description": "Popover will be placed at the top of the reference element."
+              },
+              {
+                "value": "\"Bottom\"",
+                "description": "Popover will be placed at the bottom of the reference element."
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Top\""
+              },
+              {
+                "value": "\"Bottom\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines on which side the VariantManagement popover is placed at.",
+          "defaultValue": {
+            "value": "Bottom"
+          }
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Describes the title of the VariantManagement popover.\n\n__Note:__ If not set, the default title is used."
+        },
+        "closeOnItemSelect": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the VariantManagement should be closed if an item was selected."
+        },
+        "level": {
+          "type": {
+            "name": "enum",
+            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
+            "value": [
+              {
+                "value": "\"H1\"",
+                "description": "Renders `h1` tag."
+              },
+              {
+                "value": "\"H2\"",
+                "description": "Renders `h2` tag."
+              },
+              {
+                "value": "\"H3\"",
+                "description": "Renders `h3` tag."
+              },
+              {
+                "value": "\"H4\"",
+                "description": "Renders `h4` tag."
+              },
+              {
+                "value": "\"H5\"",
+                "description": "Renders `h5` tag."
+              },
+              {
+                "value": "\"H6\"",
+                "description": "Renders `h6` tag."
+              },
+              {
+                "value": "\"H1\""
+              },
+              {
+                "value": "\"H2\""
+              },
+              {
+                "value": "\"H3\""
+              },
+              {
+                "value": "\"H4\""
+              },
+              {
+                "value": "\"H5\""
+              },
+              {
+                "value": "\"H6\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Describes the `Title` HTML level (H1 - H6) of the selected variant. This property doesn't influence the style of the component, you can use the `size` prop for this purpose.",
+          "defaultValue": {
+            "value": "H4"
+          }
+        },
+        "size": {
+          "type": {
+            "name": "enum",
+            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
+            "value": [
+              {
+                "value": "\"H1\"",
+                "description": "Renders `h1` tag."
+              },
+              {
+                "value": "\"H2\"",
+                "description": "Renders `h2` tag."
+              },
+              {
+                "value": "\"H3\"",
+                "description": "Renders `h3` tag."
+              },
+              {
+                "value": "\"H4\"",
+                "description": "Renders `h4` tag."
+              },
+              {
+                "value": "\"H5\"",
+                "description": "Renders `h5` tag."
+              },
+              {
+                "value": "\"H6\"",
+                "description": "Renders `h6` tag."
+              },
+              {
+                "value": "\"H1\""
+              },
+              {
+                "value": "\"H2\""
+              },
+              {
+                "value": "\"H3\""
+              },
+              {
+                "value": "\"H4\""
+              },
+              {
+                "value": "\"H5\""
+              },
+              {
+                "value": "\"H6\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Describes the `Title`'s `size` of the selected variant.",
+          "defaultValue": {
+            "value": "H4"
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the VariantManagement is disabled."
+        },
+        "dirtyState": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicator for modified but not saved variants.\n\n__Note:__ You can change the indicator by setting `dirtyStateText`."
+        },
+        "dirtyStateText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Text for the dirty state indicator.",
+          "defaultValue": {
+            "value": "*"
+          }
+        },
+        "showOnlyFavorites": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates that the 'Favorites' feature is used. Only variants marked as favorites will be displayed in the variant list.\n\n__Note:__ Only if `showOnlyFavorites` is set to `true` favorites can be changed."
+        },
+        "hideSetAsDefault": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates that set as default is visible in the Save View and the Manage Views dialogs."
+        },
+        "hideShare": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates that the Public indicator is visible in the Save View and the Manage Views dialogs."
+        },
+        "hideApplyAutomatically": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates that Apply Automatically is visible in the Save View and the Manage Views dialogs."
+        },
+        "hideCreatedBy": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates that the Author is visible in the Manage Views dialog."
+        },
+        "hideSaveAs": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates that the Save View dialog button is visible."
+        },
+        "hideManageVariants": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates that the Manage Views dialog button is visible."
+        },
+        "inErrorState": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates that the control is in error state. If set to true error message will be displayed whenever the variant is opened."
+        },
+        "onSelect": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListDomRef, ListSelectionChangeEventDetail & { selectedVariant: SelectedVariant; }>) => void"
+          },
+          "required": false,
+          "description": "Fired after a variant has been selected.\n\n__Note:__ This event inherits part of its details from the `onSelectionChange` event of the `List` component."
+        },
+        "onSaveAs": {
+          "type": {
+            "name": "(e: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail> & { detail: SelectedVariant & { nativeDetail: number; }; }) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the \"Save\" button is clicked inside the Save View dialog.\n\n__Note:__ Calling `event.preventDefault()` prevents the dialog from closing when clicked."
+        },
+        "onSaveManageViews": {
+          "type": {
+            "name": "(e: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail> & { detail: { nativeDetail: number; deletedVariants: VariantItemPropTypes[]; prevVariants: VariantItemPropTypes[]; updatedVariants: UpdatedVariant[]; variants: SelectedVariant[]; }; }) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the \"Save\" button is clicked inside the Manage Views dialog.\n\n__Note:__ Calling `event.preventDefault()` prevents the dialog from closing when clicked."
+        },
+        "onSave": {
+          "type": {
+            "name": "(e: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail> & { detail: SelectedVariant & { nativeDetail: number; }; }) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the \"Save\" button is clicked in the `VariantManagement` popover.\n\n__Note:__ The save button is only displayed if the `VariantManagement` is in `dirtyState` and the selected variant is not in `readOnly` mode."
+        },
+        "onManageViewsCancel": {
+          "type": {
+            "name": "(e: (Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail> | Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) & { ...; }) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the \"Cancel\" button inside the Manage Views dialog is clicked or ESCAPE is pressed."
+        },
+        "onSaveViewCancel": {
+          "type": {
+            "name": "(e: (Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail> | Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) & { ...; }) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the \"Cancel\" button inside the Save View dialog is clicked or ESCAPE is pressed."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    }
+  },
+  "webComponents": {
+    "Avatar": {
+      "package": "@ui5/webcomponents-react",
+      "description": "An image-like component that has different display options for representing images and icons\nin different shapes and sizes, depending on the use case.\n\nThe shape can be circular or square. There are several predefined sizes, as well as an option to\nset a custom size.\n\n### Keyboard Handling\n\n- [Space] / [Enter] or [Return] - Fires the `click` event if the `mode` is set to `Interactive` or the deprecated `interactive` property is set to true.\n- [Shift] - If [Space] is pressed, pressing [Shift] releases the component without triggering the click event.\n\n\n\n__Note:__ This is a UI5 Web Component! [Avatar UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Avatar) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "badge": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the optional badge that will be used for visual affordance.\n\n**Recommendation:** While badges are supported on all avatars, it is recommended\nto use them with interactive avatars (via `mode=\"Interactive\"` or `interactive` attribute)\nto provide better user experience and accessibility.\n\n**Note:** While the slot allows for custom badges, to achieve\nthe Fiori design, use the `AvatarBadge` component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"badge\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.7.0](https://github.com/UI5/webcomponents/releases/tag/v1.7.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Receives the desired `<img>` tag\n\n**Note:** If you experience flickering of the provided image, you can hide the component until it is defined with the following CSS:<br/>\n`ui5-avatar:not(:defined) {`<br/>\n&nbsp;&nbsp;&nbsp;&nbsp;`visibility: hidden;`<br/>\n`}`\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<AvatarDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired on mouseup, space and enter if avatar is interactive\n\n**Note:** The event will not be fired if the `disabled`\nproperty is set to `true`.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "AvatarAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following field is supported:\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text alternative of the component.\nIf not provided a default text alternative will be set, if present."
+        },
+        "colorScheme": {
+          "type": {
+            "name": "enum",
+            "raw": "AvatarColorScheme | \"Auto\" | \"Accent1\" | \"Accent2\" | \"Accent3\" | \"Accent4\" | \"Accent5\" | \"Accent6\" | \"Accent7\" | \"Accent8\" | \"Accent9\" | \"Accent10\" | \"Placeholder\" | \"Transparent\"",
+            "value": [
+              {
+                "value": "\"Auto\""
+              },
+              {
+                "value": "\"Accent1\""
+              },
+              {
+                "value": "\"Accent2\""
+              },
+              {
+                "value": "\"Accent3\""
+              },
+              {
+                "value": "\"Accent4\""
+              },
+              {
+                "value": "\"Accent5\""
+              },
+              {
+                "value": "\"Accent6\""
+              },
+              {
+                "value": "\"Accent7\""
+              },
+              {
+                "value": "\"Accent8\""
+              },
+              {
+                "value": "\"Accent9\""
+              },
+              {
+                "value": "\"Accent10\""
+              },
+              {
+                "value": "\"Placeholder\""
+              },
+              {
+                "value": "\"Transparent\""
+              },
+              {
+                "value": "\"Auto\""
+              },
+              {
+                "value": "\"Accent1\""
+              },
+              {
+                "value": "\"Accent2\""
+              },
+              {
+                "value": "\"Accent3\""
+              },
+              {
+                "value": "\"Accent4\""
+              },
+              {
+                "value": "\"Accent5\""
+              },
+              {
+                "value": "\"Accent6\""
+              },
+              {
+                "value": "\"Accent7\""
+              },
+              {
+                "value": "\"Accent8\""
+              },
+              {
+                "value": "\"Accent9\""
+              },
+              {
+                "value": "\"Accent10\""
+              },
+              {
+                "value": "\"Placeholder\""
+              },
+              {
+                "value": "\"Transparent\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the background color of the desired image.\nIf `colorScheme` is set to `Auto`, the avatar will be displayed with the `Accent6` color.",
+          "defaultValue": {
+            "value": "\"Auto\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "fallbackIcon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the name of the fallback icon, which should be displayed in the following cases:\n\n\t- If the initials are not valid (more than 3 letters, unsupported languages or empty initials).\n\t- If there are three initials and they do not fit in the shape (e.g. WWW for some of the sizes).\n\t- If the image src is wrong.\n\n**Note:** If not set, a default fallback icon \"employee\" is displayed.\n\n**Note:** You should import the desired icon first, then use its name as \"fallback-icon\".\n\n`import \"@ui5/webcomponents-icons/dist/{icon_name}.js\"`\n\n`<Avatar fallback-icon=\"alert\">`\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html).",
+          "defaultValue": {
+            "value": "\"employee\""
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the name of the UI5 Icon, that will be displayed.\n\n**Note:** If `image` slot is provided, the property will be ignored.\n\n**Note:** You should import the desired icon first, then use its name as \"icon\".\n\n`import \"@ui5/webcomponents-icons/dist/{icon_name}.js\"`\n\n`<Avatar icon=\"employee\">`\n\n**Note:** If no icon or an empty one is provided, by default the \"employee\" icon should be displayed.\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "initials": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the displayed initials.\n\nUp to three Latin letters can be displayed as initials."
+        },
+        "interactive": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the avatar is interactive (focusable and pressable).\n\n**Note:** When set to `true`, this property takes precedence over the `mode` property,\nand the avatar will be rendered as interactive (role=\"button\", focusable) regardless of the `mode` value.\n\n**Note:** This property won't have effect if the `disabled`\nproperty is set to `true`.\n@deprecated Set `mode=\"Interactive\"` instead for the same functionality with proper accessibility.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "mode": {
+          "type": {
+            "name": "enum",
+            "raw": "AvatarMode | \"Image\" | \"Decorative\" | \"Interactive\"",
+            "value": [
+              {
+                "value": "\"Image\"",
+                "description": "Image mode (by default).\nConfigures the component to internally render role=\"img\"."
+              },
+              {
+                "value": "\"Decorative\"",
+                "description": "Decorative mode.\nConfigures the component to internally render role=\"presentation\" and aria-hidden=\"true\",\nmaking it purely decorative without semantic content or interactivity."
+              },
+              {
+                "value": "\"Interactive\"",
+                "description": "Interactive mode.\nConfigures the component to internally render role=\"button\".\nThis mode also supports focus and enables keyboard interaction."
+              },
+              {
+                "value": "\"Image\""
+              },
+              {
+                "value": "\"Decorative\""
+              },
+              {
+                "value": "\"Interactive\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the mode of the component.\n\n**Note:**\n- `Image` (default) - renders with role=\"img\"\n- `Decorative` - renders with role=\"presentation\" and aria-hidden=\"true\", making it purely decorative\n- `Interactive` - renders with role=\"button\", focusable (tabindex=\"0\"), and supports keyboard interaction\n\n**Note:** This property is ignored when the `interactive` property is set to `true`.\nIn that case, the avatar will always be rendered as interactive.\n\n**Note:** Available since [v2.20](https://github.com/UI5/webcomponents/releases/tag/v2.20) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Image\""
+          }
+        },
+        "shape": {
+          "type": {
+            "name": "enum",
+            "raw": "AvatarShape | \"Circle\" | \"Square\"",
+            "value": [
+              {
+                "value": "\"Circle\"",
+                "description": "Circular shape."
+              },
+              {
+                "value": "\"Square\"",
+                "description": "Square shape."
+              },
+              {
+                "value": "\"Circle\""
+              },
+              {
+                "value": "\"Square\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the shape of the component.",
+          "defaultValue": {
+            "value": "\"Circle\""
+          }
+        },
+        "size": {
+          "type": {
+            "name": "enum",
+            "raw": "AvatarSize | \"XS\" | \"S\" | \"M\" | \"L\" | \"XL\"",
+            "value": [
+              {
+                "value": "\"XS\"",
+                "description": "component size - 2rem\nfont size - 1rem"
+              },
+              {
+                "value": "\"S\"",
+                "description": "component size - 3rem\nfont size - 1.5rem"
+              },
+              {
+                "value": "\"M\"",
+                "description": "component size - 4rem\nfont size - 2rem"
+              },
+              {
+                "value": "\"L\"",
+                "description": "component size - 5rem\nfont size - 2.5rem"
+              },
+              {
+                "value": "\"XL\"",
+                "description": "component size - 7rem\nfont size - 3rem"
+              },
+              {
+                "value": "\"XS\""
+              },
+              {
+                "value": "\"S\""
+              },
+              {
+                "value": "\"M\""
+              },
+              {
+                "value": "\"L\""
+              },
+              {
+                "value": "\"XL\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines predefined size of the component.",
+          "defaultValue": {
+            "value": "\"S\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<AvatarDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "AvatarBadge": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `AvatarBadge` component is used to display a badge on top of `Avatar` component.\nThe badge can display an icon and supports different states for visual affordance.\n\n### Usage\n\nThe badge should be used as a child element of `Avatar` in the `badge` slot.\n\n```html\n<Avatar>\n  <AvatarBadge icon=\"edit\" slot=\"badge\"></AvatarBadge>\n</Avatar>\n```\n\n### Keyboard Handling\n\nThe badge does not receive keyboard focus.\n\n\n\n__Note:__ This is a UI5 Web Component! [AvatarBadge UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/AvatarBadge) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon name to be displayed inside the badge.\n\n**Note:** You should import the desired icon first, then use its name as \"icon\".\n\n`import \"@ui5/webcomponents-icons/dist/{icon_name}.js\"`"
+        },
+        "state": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the state of the badge, which determines its styling.\n\nAvailable options:\n- `None` (default) - Standard appearance\n- `Positive` - Green, used for success/approved states\n- `Critical` - Orange, used for warning states\n- `Negative` - Red, used for error/rejected states\n- `Information` - Blue, used for informational states",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<AvatarBadgeDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "AvatarGroup": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Displays a group of avatars arranged horizontally. It is useful to visually\nshowcase a group of related avatars, such as, project team members or employees.\n\nThe component allows you to display the avatars in different sizes,\ndepending on your use case.\n\nThe `AvatarGroup` component has two group types:\n\n- `Group` type: The avatars are displayed as partially overlapped on\ntop of each other and the entire group has one click/tap area.\n- `Individual` type: The avatars are displayed side-by-side and each\navatar has its own click/tap area.\n\n### Usage\n\nUse the `AvatarGroup` if:\n\n- You want to display a group of avatars.\n- You want to display several avatars which have something in common.\n\nDo not use the `AvatarGroup` if:\n\n- You want to display a single avatar.\n- You want to display a gallery for simple images.\n- You want to use it for other visual content than avatars.\n\n### Responsive Behavior\n\nWhen the available space is less than the width required to display all avatars,\nan overflow visualization appears as a button placed at the end with the same shape\nand size as the avatars. The visualization displays the number of avatars that have overflowed\nand are not currently visible.\n\n### Keyboard Handling\nThe component provides advanced keyboard handling.\nWhen focused, the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n`type` Individual:\n\n- [Tab] - Move focus to the overflow button\n- [Left] - Navigate one avatar to the left\n- [Right] - Navigate one avatar to the right\n- [Home] - Navigate to the first avatar\n- [End] - Navigate to the last avatar\n- [Space] / [Enter] or [Return] - Trigger `ui5-click` event\n\n`type` Group:\n\n- [Tab] - Move focus to the next interactive element after the component\n- [Space] / [Enter] or [Return] - Trigger `ui5-click` event\n\n__Note:__ This is a UI5 Web Component! [AvatarGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/AvatarGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the component. Use the `Avatar` component as an item.\n\n**Note:** The UX guidelines recommends using avatars with \"Circle\" shape.\n\nMoreover, if you use avatars with \"Square\" shape, there will be visual inconsistency\nas the built-in overflow action has \"Circle\" shape.\n\n__Supported Node Type/s:__ `Array<IAvatarGroupItem>`"
+        },
+        "overflowButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the overflow button of the component.\n\n**Note:** We recommend using the `Button` component.\n\n**Note:** If this slot is not used, the component will display the built-in overflow button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"overflowButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<AvatarGroupDomRef, AvatarGroupClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is activated either with a\nclick/tap or by using the Enter or Space key.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "overflowButtonClicked",
+                "type": "boolean",
+                "description": "indicates if the overflow button is clicked"
+              },
+              {
+                "name": "targetRef",
+                "type": "HTMLElement",
+                "description": "The DOM ref of the clicked item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": false
+          }
+        },
+        "onOverflow": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<AvatarGroupDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the count of visible `Avatar` elements in the\ncomponent has changed\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "AvatarGroupAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following field is supported:\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the AvatarGroup.\nWhen provided, this will override the default aria-label text.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(s) of the elements that describe the AvatarGroup.\nWhen provided, this will be used as aria-labelledby instead of aria-label.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents**."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "AvatarGroupType | \"Group\" | \"Individual\"",
+            "value": [
+              {
+                "value": "\"Group\"",
+                "description": "The avatars are displayed as partially overlapped on top of each other and the entire group has one click or tap area."
+              },
+              {
+                "value": "\"Individual\"",
+                "description": "The avatars are displayed side-by-side and each avatar has its own click or tap area."
+              },
+              {
+                "value": "\"Group\""
+              },
+              {
+                "value": "\"Individual\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the mode of the `AvatarGroup`.",
+          "defaultValue": {
+            "value": "\"Group\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<AvatarGroupDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Bar": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The Bar is a container which is primarily used to hold titles, buttons and input elements\nand its design and functionality is the basis for page headers and footers.\nThe component consists of three areas to hold its content - startContent slot, default slot and endContent slot.\nIt has the capability to center content, such as a title, while having other components on the left and right side.\n\n### Usage\nWith the use of the design property, you can set the style of the Bar to appear designed like a Header, Subheader, Footer and FloatingFooter.\n\n**Note:** Do not place a Bar inside another Bar or inside any bar-like component. Doing so may cause unpredictable behavior.\n\n### Responsive Behavior\nThe default slot will be centered in the available space between the startContent and the endContent areas,\ntherefore it might not always be centered in the entire bar.\n\n### Keyboard Handling\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [Bar UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Bar) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content in the middle of the bar.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "endContent": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content at the end of the bar.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"endContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "startContent": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content at the start of the bar.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"startContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the bar.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "BarAccessibleRole | \"Toolbar\" | \"None\"",
+            "value": [
+              {
+                "value": "\"Toolbar\"",
+                "description": "Represents the ARIA role \"toolbar\"."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Represents the ARIA role \"none\"."
+              },
+              {
+                "value": "\"Toolbar\""
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Specifies the ARIA role applied to the component for accessibility purposes.\n\n**Note:**\n\n- Set accessibleRole to \"toolbar\" only when the component contains two or more active, interactive elements (such as buttons, links, or input fields) within the bar.\n\n- If there is only one or no active element, it is recommended to avoid using the \"toolbar\" role, as it implies a grouping of multiple interactive controls.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Toolbar\""
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "BarDesign | \"Header\" | \"Subheader\" | \"Footer\" | \"FloatingFooter\"",
+            "value": [
+              {
+                "value": "\"Header\"",
+                "description": "Default type"
+              },
+              {
+                "value": "\"Subheader\"",
+                "description": "Subheader type"
+              },
+              {
+                "value": "\"Footer\"",
+                "description": "Footer type"
+              },
+              {
+                "value": "\"FloatingFooter\"",
+                "description": "Floating Footer type - there is visible border on all sides"
+              },
+              {
+                "value": "\"Header\""
+              },
+              {
+                "value": "\"Subheader\""
+              },
+              {
+                "value": "\"Footer\""
+              },
+              {
+                "value": "\"FloatingFooter\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component's design.",
+          "defaultValue": {
+            "value": "\"Header\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<BarDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "bar",
+          "description": "Used to style the wrapper of the content of the component"
+        },
+        {
+          "name": "endContent",
+          "description": "Used to style the wrapper of the end content of the component"
+        },
+        {
+          "name": "midContent",
+          "description": "Used to style the wrapper of the middle content of the component"
+        },
+        {
+          "name": "startContent",
+          "description": "Used to style the wrapper of the start content of the component"
+        }
+      ]
+    },
+    "BarcodeScannerDialog": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `BarcodeScannerDialog` component provides barcode scanning functionality for all devices that support the `MediaDevices.getUserMedia()` native API.\nOpening the dialog launches the device camera and scans for known barcode formats.\n\nA `scanSuccess` event fires whenever a barcode is identified\nand a `scanError` event fires when the scan failed (for example, due to missing permisions).\n\nInternally, the component  uses the zxing-js/library third party OSS.\n\nFor a list of supported barcode formats, see the [zxing-js/library](https://github.com/zxing-js/library) documentation.\n\n__Note:__ This is a UI5 Web Component! [BarcodeScannerDialog UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/BarcodeScannerDialog) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "footer": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the footer HTML Element.\n\n**Note:** When you provide custom content for the `footer` slot, the default close button is not rendered.\nThis means you need to include your own mechanism within the custom `footer` to close the dialog,\nsuch as a button with an event listener that closes the dialog.\n\n**Note:** If the `footer` slot is not provided, a default footer with a close button is rendered automatically,\nallowing users to close the dialog without any additional implementation.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header HTML Element.\n\n**Note:** If `header` slot is provided, the labelling of the dialog is a responsibility of the application developer.\n`accessibleName` should be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<BarcodeScannerDialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user closes the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onScanError": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<BarcodeScannerDialogDomRef, BarcodeScannerDialogScanErrorEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fires when the scan fails with error.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "message",
+                "type": "string",
+                "description": "the error message"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onScanSuccess": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<BarcodeScannerDialogDomRef, BarcodeScannerDialogScanSuccessEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fires when the scan is completed successfuuly.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "rawBytes",
+                "type": "Object",
+                "description": "the scan result as a Uint8Array"
+              },
+              {
+                "name": "text",
+                "type": "string",
+                "description": "the scan result as string"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the dialog is open.\n\n**Note:** Available since [v1.24.0](https://github.com/UI5/webcomponents/releases/tag/v1.24.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<BarcodeScannerDialogDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Breadcrumbs": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Enables users to navigate between items by providing a list of links to previous steps in the user's navigation path.\nIt helps the user to be aware of their location within the application and allows faster navigation.\n\nThe last three steps can be accessed as links directly, while the remaining links prior to them are available\nin a drop-down menu.\n\nYou can choose the type of separator to be used from a number of predefined options.\n\n### Keyboard Handling\nThe `Breadcrumbs` provides advanced keyboard handling.\n\n- [F4], [Alt] + [Up], [Alt] + [Down], [Space], or [Enter] - If the dropdown arrow is focused - opens/closes the drop-down.\n- [Space],[Enter] - Activates the focused item and triggers the `item-click` event.\n- [Escape] - Closes the drop-down.\n- [Left] - If the drop-down is closed - navigates one item to the left.\n- [Right] - If the drop-down is closed - navigates one item to the right.\n- [Up] - If the drop-down is open - moves focus to the next item.\n- [Down] - If the drop-down is open - moves focus to the previous item.\n- [Home] - Navigates to the first item.\n- [End] - Navigates to the last item.\n\n__Note:__ This is a UI5 Web Component! [Breadcrumbs UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Breadcrumbs) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the component items.\n\n**Note:** Use the `BreadcrumbsItem` component to define the desired items.\n\n__Supported Node Type/s:__ `Array<BreadcrumbsItem>`"
+        },
+        "onItemClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<BreadcrumbsDomRef, BreadcrumbsItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fires when a `BreadcrumbsItem` is clicked.\n\n**Note:** You can prevent browser location change by calling `event.preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "altKey",
+                "type": "Boolean",
+                "description": "Returns whether the \"ALT\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "ctrlKey",
+                "type": "Boolean",
+                "description": "Returns whether the \"CTRL\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The clicked item."
+              },
+              {
+                "name": "metaKey",
+                "type": "Boolean",
+                "description": "Returns whether the \"META\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "shiftKey",
+                "type": "Boolean",
+                "description": "Returns whether the \"SHIFT\" key was pressed when the event was triggered."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "BreadcrumbsDesign | \"Standard\" | \"NoCurrentPage\"",
+            "value": [
+              {
+                "value": "\"Standard\"",
+                "description": "Shows the current page as the last item in the trail.\nThe last item contains only plain text and is not a link."
+              },
+              {
+                "value": "\"NoCurrentPage\"",
+                "description": "All items are displayed as links."
+              },
+              {
+                "value": "\"Standard\""
+              },
+              {
+                "value": "\"NoCurrentPage\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the visual appearance of the last BreadcrumbsItem.\n\nThe Breadcrumbs supports two visual appearances for the last BreadcrumbsItem:\n- \"Standard\" - displaying the last item as \"current page\" (bold and without separator)\n- \"NoCurrentPage\" - displaying the last item as a regular BreadcrumbsItem, followed by separator",
+          "defaultValue": {
+            "value": "\"Standard\""
+          }
+        },
+        "separators": {
+          "type": {
+            "name": "enum",
+            "raw": "BreadcrumbsSeparator | \"Slash\" | \"BackSlash\" | \"DoubleBackSlash\" | \"DoubleGreaterThan\" | \"DoubleSlash\" | \"GreaterThan\"",
+            "value": [
+              {
+                "value": "\"Slash\"",
+                "description": "The separator appears as \"/\"."
+              },
+              {
+                "value": "\"BackSlash\"",
+                "description": "The separator appears as \"\\\"."
+              },
+              {
+                "value": "\"DoubleBackSlash\"",
+                "description": "The separator appears as \"\\\\\"."
+              },
+              {
+                "value": "\"DoubleGreaterThan\"",
+                "description": "The separator appears as \">>\"."
+              },
+              {
+                "value": "\"DoubleSlash\"",
+                "description": "The separator appears as \"//\" ."
+              },
+              {
+                "value": "\"GreaterThan\"",
+                "description": "The separator appears as \">\"."
+              },
+              {
+                "value": "\"Slash\""
+              },
+              {
+                "value": "\"BackSlash\""
+              },
+              {
+                "value": "\"DoubleBackSlash\""
+              },
+              {
+                "value": "\"DoubleGreaterThan\""
+              },
+              {
+                "value": "\"DoubleSlash\""
+              },
+              {
+                "value": "\"GreaterThan\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the visual style of the separator between the breadcrumb items.",
+          "defaultValue": {
+            "value": "\"Slash\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<BreadcrumbsDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "BreadcrumbsItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `BreadcrumbsItem` component defines the content of an item in `Breadcrumbs`.\n\n__Note:__ This is a UI5 Web Component! [BreadcrumbsItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/BreadcrumbsItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the item."
+        },
+        "href": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the link href.\n\n**Note:** Standard hyperlink behavior is supported."
+        },
+        "target": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the link target.\n\nAvailable options are:\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `_search`\n\n**Note:** This property must only be used when the `href` property is set."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<BreadcrumbsItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "BusyIndicator": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `BusyIndicator` signals that some operation is going on and that the\nuser must wait. It does not block the current UI screen so other operations could be triggered in parallel.\nIt displays 3 dots and each dot expands and shrinks at a different rate, resulting in a cascading flow of animation.\n\n### Usage\nFor the `BusyIndicator` you can define the size, the text and whether it is shown or hidden.\nIn order to hide it, use the \"active\" property.\n\nIn order to show busy state over an HTML element, simply nest the HTML element in a `BusyIndicator` instance.\n\n**Note:** Since `BusyIndicator` has `display: inline-block;` by default and no width of its own,\nwhenever you need to wrap a block-level element, you should set `display: block` to the busy indicator as well.\n\n#### When to use:\n\n- The user needs to be able to cancel the operation.\n- Only part of the application or a particular component is affected.\n\n#### When not to use:\n\n- The operation takes less than one second.\n- You need to block the screen and prevent the user from starting another activity.\n- Do not show multiple busy indicators at once.\n\n\n\n__Note:__ This is a UI5 Web Component! [BusyIndicator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/BusyIndicator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Determines the content over which the component will appear.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "active": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the busy indicator is visible on the screen. By default it is not.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "delay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the busy indicator will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "size": {
+          "type": {
+            "name": "enum",
+            "raw": "BusyIndicatorSize | \"S\" | \"M\" | \"L\"",
+            "value": [
+              {
+                "value": "\"S\"",
+                "description": "small size"
+              },
+              {
+                "value": "\"M\"",
+                "description": "medium size"
+              },
+              {
+                "value": "\"L\"",
+                "description": "large size"
+              },
+              {
+                "value": "\"S\""
+              },
+              {
+                "value": "\"M\""
+              },
+              {
+                "value": "\"L\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the size of the component.",
+          "defaultValue": {
+            "value": "\"M\""
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines text to be displayed below the component. It can be used to inform the user of the current operation."
+        },
+        "textPlacement": {
+          "type": {
+            "name": "enum",
+            "raw": "BusyIndicatorTextPlacement | \"Top\" | \"Bottom\"",
+            "value": [
+              {
+                "value": "\"Top\"",
+                "description": "The text will be displayed on top of the busy indicator."
+              },
+              {
+                "value": "\"Bottom\"",
+                "description": "The text will be displayed at the bottom of the busy indicator."
+              },
+              {
+                "value": "\"Top\""
+              },
+              {
+                "value": "\"Bottom\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the placement of the text.",
+          "defaultValue": {
+            "value": "\"Bottom\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<BusyIndicatorDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Button": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Button` component represents a simple push button.\nIt enables users to trigger actions by clicking or tapping the `Button`, or by pressing\ncertain keyboard keys, such as Enter.\n\n### Usage\n\nFor the `Button` UI, you can define text, icon, or both. You can also specify\nwhether the text or the icon is displayed first.\n\nYou can choose from a set of predefined types that offer different\nstyling to correspond to the triggered action.\n\nYou can set the `Button` as enabled or disabled. An enabled\n`Button` can be pressed by clicking or tapping it. The button changes\nits style to provide visual feedback to the user that it is pressed or hovered over with\nthe mouse cursor. A disabled `Button` appears inactive and cannot be pressed.\n\n\n\n__Note:__ This is a UI5 Web Component! [Button UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Button) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "badge": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Adds a badge to the button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"badge\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<ButtonBadge>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is activated either with a mouse/tap or by using the Enter or Space key.\n\n**Note:** The event will not be fired if the `disabled` property is set to `true`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ButtonAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls, is currently expanded or collapsed.\nAccepts the following string values: `true` or `false`\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n- **ariaLabel**: Defines the accessible ARIA name of the component.\nAccepts any string value.\n\n - **ariaKeyShortcuts**: Defines keyboard shortcuts that activate or give focus to the button.\n\n- **controls**: Identifies the element (or elements) whose contents or presence are controlled by the button element.\nAccepts a lowercase string value.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "ButtonAccessibleRole | \"Button\" | \"Link\"",
+            "value": [
+              {
+                "value": "\"Button\"",
+                "description": "Represents Default (button) ARIA role."
+              },
+              {
+                "value": "\"Link\"",
+                "description": "Represents the ARIA role \"link\"."
+              },
+              {
+                "value": "\"Button\""
+              },
+              {
+                "value": "\"Link\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Describes the accessibility role of the button.\n\n**Note:** Use <code>ButtonAccessibleRole.Link</code> role only with a press handler, which performs a navigation. In all other scenarios the default button semantics are recommended.\n\n**Note:** Available since [v1.23](https://github.com/UI5/webcomponents/releases/tag/v1.23) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Button\""
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "ButtonDesign | \"Default\" | \"Positive\" | \"Negative\" | \"Transparent\" | \"Emphasized\" | \"Attention\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "default type (no special styling)"
+              },
+              {
+                "value": "\"Positive\"",
+                "description": "accept type (green button)"
+              },
+              {
+                "value": "\"Negative\"",
+                "description": "reject style (red button)"
+              },
+              {
+                "value": "\"Transparent\"",
+                "description": "transparent type"
+              },
+              {
+                "value": "\"Emphasized\"",
+                "description": "emphasized type"
+              },
+              {
+                "value": "\"Attention\"",
+                "description": "attention type"
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Transparent\""
+              },
+              {
+                "value": "\"Emphasized\""
+              },
+              {
+                "value": "\"Attention\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component design.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "endIcon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon, displayed as graphical element within the component after the button text.\n\n**Note:** It is highly recommended to use `endIcon` property only together with `icon` and/or `text` properties.\nUsage of `endIcon` only should be avoided.\n\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon, displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the button shows a loading indicator.\n\n**Note:** If set to `true`, a busy indicator component will be displayed on the related button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Specifies the delay in milliseconds before the loading indicator appears within the associated button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "submits": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "When set to `true`, the component will\nautomatically submit the nearest HTML form element on `press`.\n\n**Note:** This property is only applicable within the context of an HTML Form element.`\n@deprecated Set the \"type\" property to \"Submit\" to achieve the same result. The \"submits\" property is ignored if \"type\" is set to any value other than \"Button\".",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\n**Note:** A tooltip attribute should be provided for icon-only buttons, in order to represent their exact meaning/function.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Button\" | ButtonType | \"Submit\" | \"Reset\"",
+            "value": [
+              {
+                "value": "\"Button\""
+              },
+              {
+                "value": "\"Button\"",
+                "description": "The button does not do anything special when inside a form"
+              },
+              {
+                "value": "\"Submit\"",
+                "description": "The button acts as a submit button (submits a form)"
+              },
+              {
+                "value": "\"Reset\"",
+                "description": "The button acts as a reset button (resets a form)"
+              },
+              {
+                "value": "\"Submit\""
+              },
+              {
+                "value": "\"Reset\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines whether the button has special form-related functionality.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Button\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ButtonDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ButtonBadge": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ButtonBadge` component defines a badge that appears in the `Button`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ButtonBadge UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ButtonBadge) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "ButtonBadgeDesign | \"InlineText\" | \"OverlayText\" | \"AttentionDot\"",
+            "value": [
+              {
+                "value": "\"InlineText\"",
+                "description": "The badge is displayed after the text, inside the button."
+              },
+              {
+                "value": "\"OverlayText\"",
+                "description": "The badge is displayed at the top-end corner of the button.\n\n**Note:** According to design guidance, the OverlayText design mode is best used in cozy density to avoid potential visual issues in compact."
+              },
+              {
+                "value": "\"AttentionDot\"",
+                "description": "The badge is displayed as an attention dot."
+              },
+              {
+                "value": "\"InlineText\""
+              },
+              {
+                "value": "\"OverlayText\""
+              },
+              {
+                "value": "\"AttentionDot\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the badge placement and appearance.\n- **InlineText** - displayed inside the button after its text, and recommended for **compact** density.\n- **OverlayText** - displayed at the top-end corner of the button, and recommended for **cozy** density.\n- **AttentionDot** - displayed at the top-end corner of the button as a dot, and suitable for both **cozy** and **compact** densities.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"AttentionDot\""
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Text is not applied when the `design` property is set to `AttentionDot`.\n\n**Note:** The badge component only accepts numeric values and the \"+\" symbol. Using other characters or formats may result in unpredictable behavior, which is not guaranteed or supported.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ButtonBadgeDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Calendar": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Calendar` component allows users to select one or more dates.\n\nCurrently selected dates are represented with instances of `CalendarDate` as\nchildren of the `Calendar`. The value property of each `CalendarDate` must be a\ndate string, correctly formatted according to the `Calendar`'s `formatPattern` property.\nWhenever the user changes the date selection, `Calendar` will automatically create/remove instances\nof `CalendarDate` in itself, unless you prevent this behavior by calling `preventDefault()` for the\n`selection-change` event. This is useful if you want to control the selected dates externally.\n\n### Usage\n\nThe user can navigate to a particular date by:\n\n- Pressing over a month inside the months view\n- Pressing over an year inside the years view\n\nThe user can confirm a date selection by pressing over a date inside the days view.\n\n### Keyboard Handling\nThe `Calendar` provides advanced keyboard handling.\nWhen a picker is showed and focused the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- Day picker:\n\n- [F4] - Shows month picker\n- [Shift] + [F4] - Shows year picker\n- [Page Up] - Navigate to the previous month\n- [Page Down] - Navigate to the next month\n- [Shift] + [Page Up] - Navigate to the previous year\n- [Shift] + [Page Down] - Navigate to the next year\n- [Ctrl] + [Shift] + [Page Up] - Navigate ten years backwards\n- [Ctrl] + [Shift] + [Page Down] - Navigate ten years forwards\n- [Home] - Navigate to the first day of the week\n- [End] - Navigate to the last day of the week\n- [Ctrl] + [Home] - Navigate to the first day of the month\n- [Ctrl] + [End] - Navigate to the last day of the month\n\n- Month picker:\n\n- [Page Up] - Navigate to the previous year\n- [Page Down] - Navigate to the next year\n- [Home] - Navigate to the first month of the current row\n- [End] - Navigate to the last month of the current row\n- [Ctrl] + [Home] - Navigate to the first month of the current year\n- [Ctrl] + [End] - Navigate to the last month of the year\n\n- Year picker:\n\n- [Page Up] - Navigate to the previous year range\n- [Page Down] - Navigate the next year range\n- [Home] - Navigate to the first year of the current row\n- [End] - Navigate to the last year of the current row\n- [Ctrl] + [Home] - Navigate to the first year of the current year range\n- [Ctrl] + [End] - Navigate to the last year of the current year range\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n### Calendar types\nThe component supports several calendar types - Gregorian, Buddhist, Islamic, Japanese and Persian.\nBy default the Gregorian Calendar is used. In order to use the Buddhist, Islamic, Japanese or Persian calendar,\nyou need to set the `primaryCalendarType` property and import one or more of the following modules:\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Buddhist.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Islamic.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Japanese.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Persian.js\";`\n\nOr, you can use the global configuration and set the `calendarType` key:\n\n```html\n<script data-id=\"sap-ui-config\" type=\"application/json\">\n\t{\n\t\t\"calendarType\": \"Japanese\"\n\t}\n</script>\n```\n\n\n\n__Note:__ This is a UI5 Web Component! [Calendar UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Calendar) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "calendarLegend": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the calendar legend of the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"calendarLegend\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<CalendarLegend>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the selected date or dates (depending on the `selectionMode` property)\nfor this calendar as instances of `CalendarDate` or `CalendarDateRange`.\nUse `CalendarDate` for single or multiple selection, and `CalendarDateRange` for range selection.\n\n__Supported Node Type/s:__ `Array<ICalendarSelectedDates>`"
+        },
+        "disabledDates": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the disabled date ranges that cannot be selected in the calendar.\nUse `CalendarDateRange` elements to specify ranges of disabled dates.\nEach range can define a start date, an end date, or both.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"disabledDates\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<CalendarDateRange>`"
+        },
+        "specialDates": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the special dates, visually emphasized in the calendar.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"specialDates\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<SpecialCalendarDate>`"
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<CalendarDomRef, CalendarSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the selected dates change.\n\n**Note:** If you call `preventDefault()` for this event, the component will not\ncreate instances of `CalendarDate` for the newly selected dates. In that case you should do this manually.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "selectedDates",
+                "type": "Array<number>",
+                "description": "The selected dates as UTC timestamps"
+              },
+              {
+                "name": "selectedValues",
+                "type": "Array<string>",
+                "description": "The selected dates"
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "calendarWeekNumbering": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarWeekNumbering | \"Default\" | \"ISO_8601\" | \"MiddleEastern\" | \"WesternTraditional\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "The default calendar week numbering:\n\nThe framework determines the week numbering scheme; currently it is derived from the\nactive format locale. Future versions of ui5-webcomponents might select a different week numbering\nscheme."
+              },
+              {
+                "value": "\"ISO_8601\"",
+                "description": "Official calendar week numbering in most of Europe (ISO 8601 standard):\nMonday is first day of the week, the week containing January 4th is first week of the year."
+              },
+              {
+                "value": "\"MiddleEastern\"",
+                "description": "Official calendar week numbering in much of the Middle East (Middle Eastern calendar):\nSaturday is first day of the week, the week containing January 1st is first week of the year."
+              },
+              {
+                "value": "\"WesternTraditional\"",
+                "description": "Official calendar week numbering in the United States, Canada, Brazil, Israel, Japan, and\nother countries (Western traditional calendar):\nSunday is first day of the week, the week containing January 1st is first week of the year."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"ISO_8601\""
+              },
+              {
+                "value": "\"MiddleEastern\""
+              },
+              {
+                "value": "\"WesternTraditional\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines how to calculate calendar weeks and first day of the week.\nIf not set, the calendar will be displayed according to the currently set global configuration.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "displayFormat": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, displayed in the input field.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "formatPattern": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, displayed in the input field.\n@deprecated Use displayFormat and valueFormat instead"
+        },
+        "hideWeekNumbers": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the visibility of the week numbers column.\n\n**Note:** For calendars other than Gregorian,\nthe week numbers are not displayed regardless of what is set.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "maxDate": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the maximum date available for selection.\n\n**Note:** If the formatPattern property is not set, the maxDate value must be provided in the ISO date format (yyyy-MM-dd)."
+        },
+        "minDate": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the minimum date available for selection.\n\n**Note:** If the formatPattern property is not set, the minDate value must be provided in the ISO date format (yyyy-MM-dd)."
+        },
+        "primaryCalendarType": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
+            "value": [
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              },
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Sets a calendar type used for display.\nIf not set, the calendar type of the global configuration is used."
+        },
+        "secondaryCalendarType": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
+            "value": [
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              },
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the secondary calendar type.\nIf not set, the calendar will only show the primary calendar type."
+        },
+        "selectionMode": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarSelectionMode | \"Single\" | \"Multiple\" | \"Range\"",
+            "value": [
+              {
+                "value": "\"Single\"",
+                "description": "Only one date can be selected at a time"
+              },
+              {
+                "value": "\"Multiple\"",
+                "description": "Several dates can be selected"
+              },
+              {
+                "value": "\"Range\"",
+                "description": "A range defined by a start date and an end date can be selected"
+              },
+              {
+                "value": "\"Single\""
+              },
+              {
+                "value": "\"Multiple\""
+              },
+              {
+                "value": "\"Range\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the type of selection used in the calendar component.\nAccepted property values are:\n\n- `CalendarSelectionMode.Single` - enables a single date selection.(default value)\n- `CalendarSelectionMode.Range` - enables selection of a date range.\n- `CalendarSelectionMode.Multiple` - enables selection of multiple dates.",
+          "defaultValue": {
+            "value": "\"Single\""
+          }
+        },
+        "valueFormat": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, used for the value attribute.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<CalendarDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "calendar-header-arrow-button",
+          "description": "Used to style the calendar header navigation arrow buttons (previous/next buttons)."
+        },
+        {
+          "name": "calendar-header-middle-button",
+          "description": "Used to style the calendar header middle buttons (month/year/year-range buttons)."
+        },
+        {
+          "name": "day-cell",
+          "description": "Used to style the day cells."
+        },
+        {
+          "name": "day-cell-selected",
+          "description": "Used to style the day cells when selected."
+        },
+        {
+          "name": "day-cell-selected-between",
+          "description": "Used to style the day cells in between of selected dates in range."
+        },
+        {
+          "name": "month-cell",
+          "description": "Used to style the month cells."
+        },
+        {
+          "name": "month-cell-selected",
+          "description": "Used to style the month cells when selected."
+        },
+        {
+          "name": "month-cell-selected-between",
+          "description": "Used to style the day cells in between of selected months in range."
+        },
+        {
+          "name": "month-picker-root",
+          "description": "Used to style the month picker root container."
+        },
+        {
+          "name": "year-cell",
+          "description": "Used to style the year cells."
+        },
+        {
+          "name": "year-cell-selected",
+          "description": "Used to style the year cells when selected."
+        },
+        {
+          "name": "year-cell-selected-between",
+          "description": "Used to style the year cells in between of selected years in range."
+        },
+        {
+          "name": "year-picker-root",
+          "description": "Used to style the year picker root container."
+        },
+        {
+          "name": "year-range-cell",
+          "description": "Used to style the year range cells."
+        },
+        {
+          "name": "year-range-cell-selected",
+          "description": "Used to style the year range cells when selected."
+        },
+        {
+          "name": "year-range-cell-selected-between",
+          "description": "Used to style the year range cells in between of selected year ranges."
+        },
+        {
+          "name": "year-range-picker-root",
+          "description": "Used to style the year range picker root container."
+        }
+      ]
+    },
+    "CalendarDate": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `CalendarDate` component defines a calendar date to be used inside `Calendar`\n\n__Note:__ This is a UI5 Web Component! [CalendarDate UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CalendarDate) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "The date formatted according to the `formatPattern` property\nof the `Calendar` that hosts the component."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<CalendarDateDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "CalendarDateRange": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `CalendarDateRange` component defines a range of dates to be used inside `Calendar`\n\n__Note:__ This is a UI5 Web Component! [CalendarDateRange UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CalendarDateRange) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "endValue": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "End of date range formatted according to the `formatPattern` property\nof the `Calendar` that hosts the component."
+        },
+        "startValue": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Start of date range formatted according to the `formatPattern` property\nof the `Calendar` that hosts the component."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<CalendarDateRangeDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "CalendarLegend": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `CalendarLegend` component is designed for use within the `Calendar` to display a legend.\nEach `CalendarLegendItem` represents a unique date type, specifying its visual style\nand a corresponding textual label.\n\n\n\n__Note:__ This is a UI5 Web Component! [CalendarLegend UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CalendarLegend) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the component.\n\n__Supported Node Type/s:__ `Array<CalendarLegendItem>`"
+        },
+        "hideNonWorkingDay": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Hides the Non-Working day item in the legend.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideSelectedDay": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Hides the Selected day item in the legend.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideToday": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Hides the Today item in the legend.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideWorkingDay": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Hides the Working day item in the legend.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<CalendarLegendDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "CalendarLegendItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Each `CalendarLegendItem` represents a legend item, displaying a color with a label.\nThe color is determined by the `type` property and the label by the `text` property.\nIf a `SpecialCalendarDate` is used within the `Calendar` and a type is set, clicking on a `CalendarLegendItem`\nwith the same type will emphasize the respective date(s) in the calendar.\n\n### Usage\nThe `CalendarLegendItem` is intended to be used within the `CalendarLegend` component.\n\n\n\n__Note:__ This is a UI5 Web Component! [CalendarLegendItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CalendarLegendItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text content of the Calendar Legend Item."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarLegendItemType | \"Today\" | \"Selected\" | \"None\" | \"Working\" | \"NonWorking\" | \"Type01\" | \"Type02\" | \"Type03\" | \"Type04\" | \"Type05\" | \"Type06\" | ... 13 more ... | \"Type20\"",
+            "value": [
+              {
+                "value": "\"Today\"",
+                "description": "Represents the \"Today\" item in the calendar legend."
+              },
+              {
+                "value": "\"Selected\"",
+                "description": "Represents the \"Selected\" item in the calendar legend."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Set when no type is set."
+              },
+              {
+                "value": "\"Working\"",
+                "description": "Represents the \"Working\" item in the calendar legend."
+              },
+              {
+                "value": "\"NonWorking\"",
+                "description": "Represents the \"NonWorking\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type01\"",
+                "description": "Represents the \"Type01\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type02\"",
+                "description": "Represents the \"Type02\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type03\"",
+                "description": "Represents the \"Type03\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type04\"",
+                "description": "Represents the \"Type04\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type05\"",
+                "description": "Represents the \"Type05\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type06\"",
+                "description": "Represents the \"Type06\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type07\"",
+                "description": "Represents the \"Type07\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type08\"",
+                "description": "Represents the \"Type08\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type09\"",
+                "description": "Represents the \"Type09\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type10\"",
+                "description": "Represents the \"Type10\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type11\"",
+                "description": "Represents the \"Type11\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type12\"",
+                "description": "Represents the \"Type12\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type13\"",
+                "description": "Represents the \"Type13\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type14\"",
+                "description": "Represents the \"Type14\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type15\"",
+                "description": "Represents the \"Type15\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type16\"",
+                "description": "Represents the \"Type16\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type17\"",
+                "description": "Represents the \"Type17\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type18\"",
+                "description": "Represents the \"Type18\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type19\"",
+                "description": "Represents the \"Type19\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type20\"",
+                "description": "Represents the \"Type20\" item in the calendar legend."
+              },
+              {
+                "value": "\"Today\""
+              },
+              {
+                "value": "\"Selected\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Working\""
+              },
+              {
+                "value": "\"NonWorking\""
+              },
+              {
+                "value": "\"Type01\""
+              },
+              {
+                "value": "\"Type02\""
+              },
+              {
+                "value": "\"Type03\""
+              },
+              {
+                "value": "\"Type04\""
+              },
+              {
+                "value": "\"Type05\""
+              },
+              {
+                "value": "\"Type06\""
+              },
+              {
+                "value": "\"Type07\""
+              },
+              {
+                "value": "\"Type08\""
+              },
+              {
+                "value": "\"Type09\""
+              },
+              {
+                "value": "\"Type10\""
+              },
+              {
+                "value": "\"Type11\""
+              },
+              {
+                "value": "\"Type12\""
+              },
+              {
+                "value": "\"Type13\""
+              },
+              {
+                "value": "\"Type14\""
+              },
+              {
+                "value": "\"Type15\""
+              },
+              {
+                "value": "\"Type16\""
+              },
+              {
+                "value": "\"Type17\""
+              },
+              {
+                "value": "\"Type18\""
+              },
+              {
+                "value": "\"Type19\""
+              },
+              {
+                "value": "\"Type20\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the type of the Calendar Legend Item.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<CalendarLegendItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Card": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Card` is a component that represents information in the form of a\ntile with separate header and content areas.\nThe content area of a `Card` can be arbitrary HTML content.\nThe header can be used through slot `header`. For which there is a `CardHeader` component to achieve the card look and feel.\n\nNote: We recommend the usage of `CardHeader` for the header slot, so advantage can be taken for keyboard handling, styling and accessibility.\n\n\n\n`import \"@ui5/webcomponents/dist/CardHeader.js\";` (for `CardHeader`)\n\n__Note:__ This is a UI5 Web Component! [Card UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Card) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header of the component.\n\n**Note:** Use `CardHeader` for the intended design.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<CardHeader>`"
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component, which is used as the name of the card region and should be unique per card.\n\n**Note:** `accessibleName` should be always set, unless `accessibleNameRef` is set."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that label the component."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if a loading indicator would be displayed over the card.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the loading indicator will show up for this card.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<CardDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "content",
+          "description": "Used to style the content of the card"
+        },
+        {
+          "name": "root",
+          "description": "Used to style the root DOM element of the card component"
+        }
+      ]
+    },
+    "CardHeader": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `CardHeader` is a component, meant to be used as a header of the `Card` component.\nIt displays valuable information, that can be defined with several properties, such as: `titleText`, `subtitleText`, `additionalText`\nand two slots: `avatar` and `action`.\n\n### Keyboard handling\nIn case you enable `interactive` property, you can press the `CardHeader` by Space and Enter keys.\n\n\n\n__Note:__ This is a UI5 Web Component! [CardHeader UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CardHeader) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "action": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines an action, displayed in the right most part of the header.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"action\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "avatar": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines an avatar image, displayed in the left most part of the header.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"avatar\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<CardHeaderDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is activated by mouse/tap or by using the Enter or Space key.\n\n**Note:** The event would be fired only if the `interactive` property is set to true.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "additionalText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the additional text."
+        },
+        "interactive": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the component would be interactive,\ne.g gets hover effect and `click` event is fired, when pressed.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "subtitleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the subtitle text."
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the title text."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<CardHeaderDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "additional-text",
+          "description": "Used to style the additional text of the CardHeader"
+        },
+        {
+          "name": "root",
+          "description": "Used to style the root DOM element of the CardHeader"
+        },
+        {
+          "name": "subtitle",
+          "description": "Used to style the subtitle of the CardHeader"
+        },
+        {
+          "name": "title",
+          "description": "Used to style the title of the CardHeader"
+        }
+      ]
+    },
+    "Carousel": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The Carousel allows the user to browse through a set of items.\nThe component is mostly used for showing a gallery of images, but can hold any other HTML element.\n\nThere are several ways to perform navigation:\n\n- on desktop - the user can navigate using the navigation arrows or with keyboard shortcuts.\n- on touch devices - the user can navigate using the navigation arrows (always visible) or can use swipe gestures.\n\n### Usage\n\n#### When to use:\n\n- The items you want to display are very different from each other.\n- You want to display the items one after the other.\n\n#### When not to use:\n\n- The items you want to display need to be visible at the same time.\n- The items you want to display are uniform and very similar.\n\n### Hidden Items\n\nCarousel items can be conditionally hidden by adding the `hidden` attribute to any child element.\nHidden items are automatically excluded from carousel navigation and will not be displayed or counted in pagination.\nThis allows for dynamic showing or hiding of carousel items without affecting the overall carousel behavior.\n\n### Keyboard Handling\n\n#### Basic Navigation\nWhen the `Carousel` is focused the user can navigate between the items\nwith the following keyboard shortcuts:\n\n- [Up] or [Down] - Navigates to previous and next item\n- [Left] or [Right] - Navigates to previous and next item\n\n### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [Carousel UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Carousel) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component.\n\n**Note:** Items with the `hidden` attribute will be automatically excluded from carousel navigation and page calculations.\nThey will not be displayed or accessible via keyboard navigation. See [sample](./#carousel-with-hidden-items).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onNavigate": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<CarouselDomRef, CarouselNavigateEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired whenever the page changes due to user interaction,\nwhen the user clicks on the navigation arrows or while resizing,\nbased on the `items-per-page` property.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "selectedIndex",
+                "type": "Integer",
+                "description": "the current selected index"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that label the input.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**."
+        },
+        "arrowsPlacement": {
+          "type": {
+            "name": "enum",
+            "raw": "CarouselArrowsPlacement | \"Content\" | \"Navigation\"",
+            "value": [
+              {
+                "value": "\"Content\"",
+                "description": "Carousel arrows are placed on the sides of the current Carousel page."
+              },
+              {
+                "value": "\"Navigation\"",
+                "description": "Carousel arrows are placed on the sides of the page indicator of the Carousel."
+              },
+              {
+                "value": "\"Content\""
+              },
+              {
+                "value": "\"Navigation\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the position of arrows.\n\nAvailable options are:\n\n- `Content` - the arrows are placed on the sides of the current page.\n- `Navigation` - the arrows are placed on the sides of the page indicator.",
+          "defaultValue": {
+            "value": "\"Content\""
+          }
+        },
+        "backgroundDesign": {
+          "type": {
+            "name": "enum",
+            "raw": "BackgroundDesign | \"Solid\" | \"Transparent\" | \"Translucent\"",
+            "value": [
+              {
+                "value": "\"Solid\"",
+                "description": "A solid background color dependent on the theme."
+              },
+              {
+                "value": "\"Transparent\"",
+                "description": "Transparent background."
+              },
+              {
+                "value": "\"Translucent\"",
+                "description": "A translucent background depending on the opacity value of the theme."
+              },
+              {
+                "value": "\"Solid\""
+              },
+              {
+                "value": "\"Transparent\""
+              },
+              {
+                "value": "\"Translucent\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the carousel's background design.\n\n**Note:** Available since [v1.14](https://github.com/UI5/webcomponents/releases/tag/v1.14) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Translucent\""
+          }
+        },
+        "cyclic": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the carousel should loop, i.e show the first page after the last page is reached and vice versa.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideNavigationArrows": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the visibility of the navigation arrows.\nIf set to true the navigation arrows will be hidden.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hidePageIndicator": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the visibility of the page indicator.\nIf set to true the page indicator will be hidden.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "itemsPerPage": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the number of items per page depending on the carousel width.\n\n- 'S' for screens smaller than 600 pixels.\n- 'M' for screens greater than or equal to 600 pixels and smaller than 1024 pixels.\n- 'L' for screens greater than or equal to 1024 pixels and smaller than 1440 pixels.\n- 'XL' for screens greater than or equal to 1440 pixels.\n\nOne item per page is shown by default.",
+          "defaultValue": {
+            "value": "\"S1 M1 L1 XL1\""
+          }
+        },
+        "pageIndicatorBackgroundDesign": {
+          "type": {
+            "name": "enum",
+            "raw": "BackgroundDesign | \"Solid\" | \"Transparent\" | \"Translucent\"",
+            "value": [
+              {
+                "value": "\"Solid\"",
+                "description": "A solid background color dependent on the theme."
+              },
+              {
+                "value": "\"Transparent\"",
+                "description": "Transparent background."
+              },
+              {
+                "value": "\"Translucent\"",
+                "description": "A translucent background depending on the opacity value of the theme."
+              },
+              {
+                "value": "\"Solid\""
+              },
+              {
+                "value": "\"Transparent\""
+              },
+              {
+                "value": "\"Translucent\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the page indicator background design.\n\n**Note:** Available since [v1.14](https://github.com/UI5/webcomponents/releases/tag/v1.14) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Solid\""
+          }
+        },
+        "pageIndicatorBorderDesign": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Solid\" | BorderDesign | \"None\"",
+            "value": [
+              {
+                "value": "\"Solid\""
+              },
+              {
+                "value": "\"Solid\"",
+                "description": "A solid border color dependent on the theme."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Specifies no border."
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the page indicator border design.\n\n**Note:** Available since [v1.14](https://github.com/UI5/webcomponents/releases/tag/v1.14) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Solid\""
+          }
+        },
+        "pageIndicatorType": {
+          "type": {
+            "name": "enum",
+            "raw": "CarouselPageIndicatorType | \"Default\" | \"Numeric\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "The page indicator will be visualized as dots if there are fewer than 9 pages.\nIf there are more pages, the page indicator will switch to displaying the current page and the total number of pages. (e.g. X of Y)"
+              },
+              {
+                "value": "\"Numeric\"",
+                "description": "The page indicator will display the current page and the total number of pages. (e.g. X of Y)"
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Numeric\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the style of the page indicator.\nAvailable options are:\n\n- `Default` - The page indicator will be visualized as dots if there are fewer than 9 pages. If there are more pages, the page indicator will switch to displaying the current page and the total number of pages. (e.g. X of Y)\n- `Numeric` - The page indicator will display the current page and the total number of pages. (e.g. X of Y)\n\n**Note:** Available since [v1.10](https://github.com/UI5/webcomponents/releases/tag/v1.10) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<CarouselDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "navigateTo",
+          "description": "Changes the currently displayed page.",
+          "params": [
+            {
+              "name": "itemIndex",
+              "type": {
+                "name": "number"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "void"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "content",
+          "description": "Used to style the content of the component"
+        }
+      ]
+    },
+    "CheckBox": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Allows the user to set a binary value, such as true/false or yes/no for an item.\n\nThe `CheckBox` component consists of a box and a label that describes its purpose.\nIf it's checked, an indicator is displayed inside the box.\nTo check/uncheck the `CheckBox`, the user has to click or tap the square\nbox or its label.\n\nThe `CheckBox` component only has 2 states - checked and unchecked.\nClicking or tapping toggles the `CheckBox` between checked and unchecked state.\n\n### Usage\n\nYou can define the checkbox text with via the `text` property. If the text exceeds the available width, it is truncated by default.\nIn case you prefer text to truncate, set the `wrappingType` property to \"None\".\nThe touchable area for toggling the `CheckBox` ends where the text ends.\n\nYou can disable the `CheckBox` by setting the `disabled` property to\n`true`,\nor use the `CheckBox` in read-only mode by setting the `readonly`\nproperty to `true`.\n\n### Keyboard Handling\n\nThe user can use the following keyboard shortcuts to toggle the checked state of the `CheckBox`.\n\n- [Space],[Enter] - Toggles between different states: checked, not checked.\n\n\n\n__Note:__ This is a UI5 Web Component! [CheckBox UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CheckBox) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<CheckBoxDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component checked state changes.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "checked": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the component is checked.\n\n**Note:** The property can be changed with user interaction,\neither by cliking/tapping on the component, or by\npressing the Enter or Space key.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "displayOnly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the `CheckBox` is in display only state.\n\nWhen set to `true`, the `CheckBox` is not interactive, not editable, not focusable\nand not in the tab chain. This setting is used for forms in review mode.\n\n**Note:** When the property `disabled` is set to `true` this property has no effect.\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "indeterminate": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is displayed as partially checked.\n\n**Note:** The indeterminate state can be set only programmatically and can’t be achieved by user\ninteraction and the resulting visual state depends on the values of the `indeterminate`\nand `checked` properties:\n\n-  If the component is checked and indeterminate, it will be displayed as partially checked\n-  If the component is checked and it is not indeterminate, it will be displayed as checked\n-  If the component is not checked, it will be displayed as not checked regardless value of the indeterminate attribute",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.\n\n**Note:** We advise against using the text property of the checkbox when there is a\nlabel associated with it to avoid having two required asterisks.\n\n**Note:** Available since [v1.3.0](https://github.com/UI5/webcomponents/releases/tag/v1.3.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the component."
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the form value of the component that is submitted when the checkbox is checked.\n\nWhen a form containing `CheckBox` elements is submitted, only the values of the\n**checked** checkboxes are included in the form data sent to the server. Unchecked\ncheckboxes do not contribute any data to the form submission.\n\nThis property is particularly useful for **checkbox groups**, where multiple checkboxes with the same `name` but different `value` properties can be used to represent a set of related options.",
+          "defaultValue": {
+            "value": "\"on\""
+          }
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | WrappingType | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines whether the component text wraps when there is not enough space.\n\n**Note:** for option \"Normal\" the text will wrap and the words will not be broken based on hyphenation.\n**Note:** for option \"None\" the text will be truncated with an ellipsis.",
+          "defaultValue": {
+            "value": "\"Normal\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<CheckBoxDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "icon",
+          "description": "Used to style the icon of the `ui5-checkbox`"
+        },
+        {
+          "name": "label",
+          "description": "Used to style the label of the `ui5-checkbox`"
+        },
+        {
+          "name": "root",
+          "description": "Used to style the outermost wrapper of the `ui5-checkbox`"
+        }
+      ]
+    },
+    "ColorPalette": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ColorPalette` provides the users with a range of predefined colors. The colors are fixed and do not change with the theme.\n\n### Usage\n\nThe `ColorPalette` is meant for users that need to select a color from a predefined set.\nTo define the colors, use the `ColorPaletteItem` component inside the default slot of the `ColorPalette`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ColorPalette UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ColorPalette) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the `ColorPaletteItem` elements.\n\n__Supported Node Type/s:__ `Array<IColorPaletteItem>`"
+        },
+        "onItemClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ColorPaletteDomRef, ColorPaletteItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user selects a color.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "color",
+                "type": "string",
+                "description": "the selected color"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": false
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ColorPaletteDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ColorPaletteItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ColorPaletteItem` component represents a color in the the `ColorPalette`.\n\n__Note:__ This is a UI5 Web Component! [ColorPaletteItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ColorPaletteItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the component is selected.\n\n**Note:** Only one item must be selected per <code>ui5-color-palette</code>.\nIf more than one item is defined as selected, the last one would be considered as the selected one.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the colour of the component.\n\n**Note:** The value should be a valid CSS color."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ColorPaletteItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ColorPalettePopover": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Represents a predefined range of colors for easier selection.\n\nOverview\nThe ColorPalettePopover provides the users with a slot to predefine colors.\n\nYou can customize them with the use of the colors property. You can specify a defaultColor and display a \"Default color\" button for the user to choose directly.\nYou can display a \"More colors...\" button that opens an additional color picker for the user to choose specific colors that are not present in the predefined range.\n\n### Usage\n\nThe palette is intended for users, who don't want to check and remember the different values of the colors and spend large amount of time to configure the right color through the color picker.\n\nFor the `ColorPalettePopover`\n\n\n__Note:__ This is a UI5 Web Component! [ColorPalettePopover UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ColorPalettePopover) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<IColorPaletteItem>`"
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ColorPalettePopoverDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `ColorPalettePopover` is closed due to user interaction.\n\n**Note:** Available since [v1.21.0](https://github.com/UI5/webcomponents/releases/tag/v1.21.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onItemClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ColorPalettePopoverDomRef, ColorPaletteItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user selects a color.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "color",
+                "type": "string",
+                "description": "the selected color"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
+        },
+        "defaultColor": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the default color of the component.\n\n**Note:** The default color should be a part of the ColorPalette colors`"
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the open | closed state of the popover.\n\n**Note:** Available since [v1.21.0](https://github.com/UI5/webcomponents/releases/tag/v1.21.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "opener": {
+          "type": {
+            "name": "string | HTMLElement"
+          },
+          "required": false,
+          "description": "Defines the ID or DOM Reference of the element that the popover is shown at.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript.\n\n**Note:** Available since [v1.21.0](https://github.com/UI5/webcomponents/releases/tag/v1.21.0) of **@ui5/webcomponents**."
+        },
+        "placement": {
+          "type": {
+            "name": "enum",
+            "raw": "PopoverPlacement | \"Start\" | \"End\" | \"Top\" | \"Bottom\"",
+            "value": [
+              {
+                "value": "\"Start\"",
+                "description": "Popover will be placed at the start of the reference element."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Popover will be placed at the end of the reference element."
+              },
+              {
+                "value": "\"Top\"",
+                "description": "Popover will be placed at the top of the reference element."
+              },
+              {
+                "value": "\"Bottom\"",
+                "description": "Popover will be placed at the bottom of the reference element."
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Top\""
+              },
+              {
+                "value": "\"Bottom\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines on which side the component is placed at.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Bottom\""
+          }
+        },
+        "showDefaultColor": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the user can choose the default color from a button.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showMoreColors": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the user can choose a custom color from a component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showRecentColors": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the user can see the last used colors in the bottom of the component",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ColorPalettePopoverDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ColorPicker": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ColorPicker` allows users to choose any color and provides different input options for selecting colors.\n\n### Usage\n\n#### When to use\nUse the color picker if:\n\n-  users need to select any color freely.\n\n#### When not to use\n\n-  Users need to select one color from a predefined set of colors. Use the ColorPalette component instead.\n\n\n\n__Note:__ This is a UI5 Web Component! [ColorPicker UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ColorPicker) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ColorPickerDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the the selected color is changed\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
+        },
+        "simplified": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "When set to `true`, the alpha slider and inputs for RGB values will not be displayed.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the currently selected color of the component.\n\n**Note**: use HEX, RGB, RGBA, HSV formats or a CSS color name when modifying this property.",
+          "defaultValue": {
+            "value": "\"rgba(255,255,255,1)\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ColorPickerDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ComboBox": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ComboBox` component represents a drop-down menu with a list of the available options and a text input field to narrow down the options.\n\nIt is commonly used to enable users to select an option from a predefined list.\n\n### Structure\nThe `ComboBox` consists of the following elements:\n\n-  Input field - displays the selected option or a custom user entry. Users can type to narrow down the list or enter their own value.\n-  Drop-down arrow - expands\\collapses the option list.\n-  Option list - the list of available options.\n\n### Working with Values\n\nThe ComboBox offers two ways to work with item selection:\n\n**1. Display Text Only (using `value`):**\n```html\n<ComboBox value=\"Germany\">\n  <ComboBoxItem text=\"Germany\"></ComboBoxItem>\n  <ComboBoxItem text=\"France\"></ComboBoxItem>\n</ComboBox>\n```\nUse this approach when the displayed text is sufficient for your needs.\n\n**2. Unique Identifiers - Recommended (using `selectedValue` and item `value`):**\n```html\n<ComboBox value=\"Germany\" selected-value=\"DE\">\n  <ComboBoxItem text=\"Germany\" value=\"DE\"></ComboBoxItem>\n  <ComboBoxItem text=\"France\" value=\"FR\"></ComboBoxItem>\n</ComboBox>\n```\nThis is the recommended approach when you need to work with unique identifiers (IDs, codes) separate from display text.\nThe `selectedValue` property references the `value` property of the selected item.\nIn forms, the item's `value` (e.g., \"DE\") will be submitted instead of the display text.\n\n**Important:** Do not mix the `selectedValue` approach with the deprecated `selected` property on items.\n\n### Keyboard Handling\n\nThe `ComboBox` provides advanced keyboard handling.\n\n- [F4], [Alt]+[Up], or [Alt]+[Down] - Toggles the picker.\n- [Escape] - Closes the picker, if open. If closed, cancels changes and reverts the typed in value.\n- [Enter] or [Return] - If picker is open, takes over the currently selected item and closes it.\n- [Down] - Selects the next matching item in the picker.\n- [Up] - Selects the previous matching item in the picker.\n- [Page Down] - Moves selection down by page size (10 items by default).\n- [Page Up] - Moves selection up by page size (10 items by default).\n- [Home] - If focus is in the ComboBox, moves cursor at the beginning of text. If focus is in the picker, selects the first item.\n- [End] - If focus is in the ComboBox, moves cursor at the end of text. If focus is in the picker, selects the last item.\n- [Ctrl]+[Alt]+[F8] or [Command]+[Option]+[F8] - Focuses the first link in the value state message, if available. Pressing [Tab] moves the focus to the next link in the value state message, or closes the value state message if there are no more links.\n\n\n\n__Note:__ This is a UI5 Web Component! [ComboBox UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ComboBox) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the component items.\n\n__Supported Node Type/s:__ `Array<IComboBoxItem>`"
+        },
+        "icon": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed in the input field.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
+        },
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the `ComboBox` is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ComboBoxDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter, focusout or an item is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ComboBoxDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the dropdown is closed.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ComboBoxDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when typing in input or clear icon is pressed.\n\n**Note:** filterValue property is updated, input is changed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ComboBoxDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the dropdown is opened.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ComboBoxDomRef, ComboBoxSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when selection is changed by user interaction\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "IComboBoxItem",
+                "description": "item to be selected."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component"
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "filter": {
+          "type": {
+            "name": "enum",
+            "raw": "ComboBoxFilter | \"StartsWithPerTerm\" | \"StartsWith\" | \"Contains\" | \"None\"",
+            "value": [
+              {
+                "value": "\"StartsWithPerTerm\"",
+                "description": "Defines filtering by first symbol of each word of item's text."
+              },
+              {
+                "value": "\"StartsWith\"",
+                "description": "Defines filtering by starting symbol of item's text."
+              },
+              {
+                "value": "\"Contains\"",
+                "description": "Defines contains filtering."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Removes any filtering applied while typing"
+              },
+              {
+                "value": "\"StartsWithPerTerm\""
+              },
+              {
+                "value": "\"StartsWith\""
+              },
+              {
+                "value": "\"Contains\""
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the filter type of the component.",
+          "defaultValue": {
+            "value": "\"StartsWithPerTerm\""
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether a loading indicator should be shown in the picker.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
+        },
+        "noTypeahead": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the value will be autocompleted to match an item\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the items picker is open.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selectedValue": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the selected item (references the `value` property of `ComboBoxItem`).\n\nUse this property to work with unique identifiers (IDs, codes) instead of display text.\nWhen set, the ComboBox finds and selects the item whose `value` property matches this property.\n\n**Benefits:**\n- Select items programmatically by their unique identifier\n- Handle items with identical display text but different underlying values\n- Submit machine-readable values in forms (the item's `value` is submitted instead of the display text)\n\n**When to use `selectedValue` vs `value`:**\n- **Recommended:** Use `selectedValue` + item `value` when you need unique identifiers separate from display text (e.g., country codes \"DE\", \"FR\" with display names \"Germany\", \"France\")\n- Use only the ComboBox `value` property when the display text itself is sufficient for your use case\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
+        },
+        "showClearIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the clear icon of the combobox will be shown.\n\n**Note:** Available since [v1.20.1](https://github.com/UI5/webcomponents/releases/tag/v1.20.1) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ComboBoxDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ComboBoxItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ComboBoxItem` represents the item for a `ComboBox`.\n\n__Note:__ This is a UI5 Web Component! [ComboBoxItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ComboBoxItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "additionalText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the additional text of the component."
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the component."
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the `ComboBoxItem`.\n\nUse this property to associate a unique identifier or machine-readable value with the item,\nseparate from the display text. This enables:\n- Selecting items programmatically via `selectedValue` on the ComboBox\n- Submitting machine-readable values in forms\n- Distinguishing between items with identical display text\n\n**When to use:**\n- **Recommended:** Use the `value` property on items together with `selectedValue` on the ComboBox when you need unique identifiers\n- Omit `value` if the display text (`text` property) is sufficient for your use case\n\n**Example:**\n```html\n<ComboBox selected-value=\"DE\">\n  <ComboBoxItem text=\"Germany\" value=\"DE\"></ComboBoxItem>\n  <ComboBoxItem text=\"France\" value=\"FR\"></ComboBoxItem>\n</ComboBox>\n```\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ComboBoxItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ComboBoxItemGroup": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ui5-cb-group-item` is type of suggestion item,\nthat can be used to split the `ComboBox` suggestions into groups.\n\n__Note:__ This is a UI5 Web Component! [ComboBoxItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ComboBoxItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the <code>ui5-cb-item-group</code>.\n\n__Supported Node Type/s:__ `Array<ComboBoxItem>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
+        },
+        "onMove": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ComboBoxItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMoveOver": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ComboBoxItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "headerAccessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the header."
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text of the <code>ui5-li-group</code>."
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "WrappingType | \"None\" | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ExpandableText` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ComboBoxItemGroupDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "header",
+          "description": "Used to style the header item of the group"
+        },
+        {
+          "name": "title",
+          "description": "Used to style the title of the group header"
+        }
+      ]
+    },
+    "DatePicker": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `DatePicker` component provides an input field with assigned calendar which opens on user action.\nThe `DatePicker` allows users to select a localized date using touch,\nmouse, or keyboard input. It consists of two parts: the date input field and the\ndate picker.\n\n### Usage\n\nThe user can enter a date by:\n\n- Using the calendar that opens in a popup\n- Typing it in directly in the input field\n\nWhen the user makes an entry and presses the enter key, the calendar shows the corresponding date.\nWhen the user directly triggers the calendar display, the actual date is displayed.\n\n### Formatting\n\nIf a date is entered by typing it into\nthe input field, it must fit to the used date format.\n\nSupported format options are pattern-based on Unicode LDML Date Format notation.\nFor more information, see [UTS #35: Unicode Locale Data Markup Language](https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table).\n\nFor example, if the valueFormat is \"yyyy-MM-dd\", the displayFormat is \"MMM d, y\", and the used locale is English, a valid value string is \"2015-07-30\", which leads to an output of \"Jul 30, 2015\".\nIf no placeholder is set to the DatePicker, the used displayFormat is displayed as a placeholder. If another placeholder is needed, it must be set.\n\n### Keyboard Handling\nThe `DatePicker` provides advanced keyboard handling.\nIf the `DatePicker` is focused,\nyou can open or close the drop-down by pressing [F4], [Alt] + [Up] or [Alt] + [Down] keys.\nOnce the drop-down is opened, you can use the [Up], [Down], [Left] or [Right] arrow keys\nto navigate through the dates and select one by pressing the `Space` or `Enter` keys. Moreover you can\nuse TAB to reach the buttons for changing month and year.\n\nIf the `DatePicker` input field is focused and its corresponding picker dialog is not opened,\nthen users can increment or decrement the date referenced by `dateValue` property\nby using the following shortcuts:\n\n- [Page Down] - Decrements the corresponding day of the month by one\n- [Shift] + [Page Down] - Decrements the corresponding month by one\n- [Shift] + [Ctrl] + [Page Down] - Decrements the corresponding year by one\n- [Page Up] - Increments the corresponding day of the month by one\n- [Shift] + [Page Up] - Increments the corresponding month by one\n- [Shift] + [Ctrl] + [Page Up] - Increments the corresponding year by one\n\n### Calendar types\nThe component supports several calendar types - Gregorian, Buddhist, Islamic, Japanese and Persian.\nBy default the Gregorian Calendar is used. In order to use the Buddhist, Islamic, Japanese or Persian calendar,\nyou need to set the `primaryCalendarType` property and import one or more of the following modules:\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Buddhist.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Islamic.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Japanese.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Persian.js\";`\n\nOr, you can use the global configuration and set the `calendarType` key:\n\n```html\n<script data-id=\"sap-ui-config\" type=\"application/json\">\n\t{\n\t\t\"calendarType\": \"Japanese\"\n\t}\n<script>\n```\n\n\n\n__Note:__ This is a UI5 Web Component! [DatePicker UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/DatePicker) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DatePickerDomRef, DatePickerChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in correct format pattern and in valid range."
+              },
+              {
+                "name": "value",
+                "type": "string",
+                "description": "The submitted value."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DatePickerDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component's picker is closed.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DatePickerDomRef, DatePickerInputEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the component is changed at each key stroke.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in correct format pattern and in valid range."
+              },
+              {
+                "name": "value",
+                "type": "string",
+                "description": "The submitted value."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DatePickerDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component's picker is opened.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onValueStateChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DatePickerDomRef, DatePickerValueStateChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the value state of the component is updated internally.\nThe event is preventable, meaning that if it's default action is\nprevented, the component will not update the value state.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in correct format pattern and in valid range."
+              },
+              {
+                "name": "valueState",
+                "type": "string",
+                "description": "The new `valueState` that will be set."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the aria-label attribute for the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component."
+        },
+        "calendarWeekNumbering": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarWeekNumbering | \"Default\" | \"ISO_8601\" | \"MiddleEastern\" | \"WesternTraditional\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "The default calendar week numbering:\n\nThe framework determines the week numbering scheme; currently it is derived from the\nactive format locale. Future versions of ui5-webcomponents might select a different week numbering\nscheme."
+              },
+              {
+                "value": "\"ISO_8601\"",
+                "description": "Official calendar week numbering in most of Europe (ISO 8601 standard):\nMonday is first day of the week, the week containing January 4th is first week of the year."
+              },
+              {
+                "value": "\"MiddleEastern\"",
+                "description": "Official calendar week numbering in much of the Middle East (Middle Eastern calendar):\nSaturday is first day of the week, the week containing January 1st is first week of the year."
+              },
+              {
+                "value": "\"WesternTraditional\"",
+                "description": "Official calendar week numbering in the United States, Canada, Brazil, Israel, Japan, and\nother countries (Western traditional calendar):\nSunday is first day of the week, the week containing January 1st is first week of the year."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"ISO_8601\""
+              },
+              {
+                "value": "\"MiddleEastern\""
+              },
+              {
+                "value": "\"WesternTraditional\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines how to calculate calendar weeks and first day of the week.\nIf not set, the calendar will be displayed according to the currently set global configuration.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is displayed as disabled.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "displayFormat": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, displayed in the input field.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "formatPattern": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, displayed in the input field.\n@deprecated Use displayFormat and valueFormat instead"
+        },
+        "hideWeekNumbers": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the visibility of the week numbers column.\n\n**Note:** For calendars other than Gregorian,\nthe week numbers are not displayed regardless of what is set.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "maxDate": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the maximum date available for selection.\n\n**Note:** If the formatPattern property is not set, the maxDate value must be provided in the ISO date format (yyyy-MM-dd)."
+        },
+        "minDate": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the minimum date available for selection.\n\n**Note:** If the formatPattern property is not set, the minDate value must be provided in the ISO date format (yyyy-MM-dd)."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the open or closed state of the popover.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint, intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** When no placeholder is set, the format pattern is displayed as a placeholder.\nPassing an empty string as the value of this property will make the component appear empty - without placeholder or format pattern."
+        },
+        "primaryCalendarType": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
+            "value": [
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              },
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Sets a calendar type used for display.\nIf not set, the calendar type of the global configuration is used."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is displayed as read-only.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "secondaryCalendarType": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
+            "value": [
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              },
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the secondary calendar type.\nIf not set, the calendar will only show the primary calendar type."
+        },
+        "showClearIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a formatted date value."
+        },
+        "valueFormat": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, used for the value attribute.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<DatePickerDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "formatValue",
+          "description": "Currently selected date represented as a Local JavaScript Date instance. Note: this getter can only be reliably used after the component is fully defined. Use dateValueAsync which resolves only when this condition is met. / readonly dateValue: Date | null; /** Promise that resolves to the currently selected date represented as a Local JavaScript Date instance. / readonly dateValueAsync: Promise<Date | null>; /** Formats a Java Script date object into a string representing a locale date according to the `formatPattern` property of the DatePicker instance",
+          "params": [
+            {
+              "name": "date",
+              "type": {
+                "name": "Date"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "string"
+          }
+        },
+        {
+          "name": "isInValidRange",
+          "description": "Checks if a date is between the minimum and maximum date.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        },
+        {
+          "name": "isValid",
+          "description": "Checks if a value is valid against the current date format of the DatePicker.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        },
+        {
+          "name": "isValidDisplayValue",
+          "description": "Checks if a value is valid against the current date format of the DatePicker.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        },
+        {
+          "name": "isValidValue",
+          "description": "Checks if a value is valid against the current date format of the DatePicker.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "input",
+          "description": "Used to style the input element. This part is forwarded to the underlying ui5-input element."
+        }
+      ]
+    },
+    "DateRangePicker": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The DateRangePicker enables the users to enter a localized date range using touch, mouse, keyboard input, or by selecting a date range in the calendar.\n\n### Usage\nThe user can enter a date by:\nUsing the calendar that opens in a popup or typing it in directly in the input field (not available for mobile devices).\nFor the `DateRangePicker`\n\n\n### Keyboard Handling\nThe `DateRangePicker` provides advanced keyboard handling.\n\nWhen the `DateRangePicker` input field is focused the user can\nincrement or decrement respectively the range start or end date, depending on where the cursor is.\nThe following shortcuts are available:\n\n- [Page Down] - Decrements the corresponding day of the month by one\n- [Shift] + [Page Down] - Decrements the corresponding month by one\n- [Shift] + [Ctrl] + [Page Down] - Decrements the corresponding year by one\n- [Page Up] - Increments the corresponding day of the month by one\n- [Shift] + [Page Up] - Increments the corresponding month by one\n- [Shift] + [Ctrl] + [Page Up] - Increments the corresponding year by one\n\n__Note:__ This is a UI5 Web Component! [DateRangePicker UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/DateRangePicker) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DateRangePickerDomRef, DatePickerChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in correct format pattern and in valid range."
+              },
+              {
+                "name": "value",
+                "type": "string",
+                "description": "The submitted value."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DateRangePickerDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component's picker is closed.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DateRangePickerDomRef, DatePickerInputEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the component is changed at each key stroke.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in correct format pattern and in valid range."
+              },
+              {
+                "name": "value",
+                "type": "string",
+                "description": "The submitted value."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DateRangePickerDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component's picker is opened.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onValueStateChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DateRangePickerDomRef, DatePickerValueStateChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the value state of the component is updated internally.\nThe event is preventable, meaning that if it's default action is\nprevented, the component will not update the value state.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in correct format pattern and in valid range."
+              },
+              {
+                "name": "valueState",
+                "type": "string",
+                "description": "The new `valueState` that will be set."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the aria-label attribute for the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component."
+        },
+        "calendarWeekNumbering": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarWeekNumbering | \"Default\" | \"ISO_8601\" | \"MiddleEastern\" | \"WesternTraditional\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "The default calendar week numbering:\n\nThe framework determines the week numbering scheme; currently it is derived from the\nactive format locale. Future versions of ui5-webcomponents might select a different week numbering\nscheme."
+              },
+              {
+                "value": "\"ISO_8601\"",
+                "description": "Official calendar week numbering in most of Europe (ISO 8601 standard):\nMonday is first day of the week, the week containing January 4th is first week of the year."
+              },
+              {
+                "value": "\"MiddleEastern\"",
+                "description": "Official calendar week numbering in much of the Middle East (Middle Eastern calendar):\nSaturday is first day of the week, the week containing January 1st is first week of the year."
+              },
+              {
+                "value": "\"WesternTraditional\"",
+                "description": "Official calendar week numbering in the United States, Canada, Brazil, Israel, Japan, and\nother countries (Western traditional calendar):\nSunday is first day of the week, the week containing January 1st is first week of the year."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"ISO_8601\""
+              },
+              {
+                "value": "\"MiddleEastern\""
+              },
+              {
+                "value": "\"WesternTraditional\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines how to calculate calendar weeks and first day of the week.\nIf not set, the calendar will be displayed according to the currently set global configuration.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "delimiter": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the symbol which separates the dates.\nIf not supplied, the default time interval delimiter for the current locale will be used.",
+          "defaultValue": {
+            "value": "\"-\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is displayed as disabled.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "displayFormat": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, displayed in the input field.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "formatPattern": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, displayed in the input field.\n@deprecated Use displayFormat and valueFormat instead"
+        },
+        "hideWeekNumbers": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the visibility of the week numbers column.\n\n**Note:** For calendars other than Gregorian,\nthe week numbers are not displayed regardless of what is set.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "maxDate": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the maximum date available for selection.\n\n**Note:** If the formatPattern property is not set, the maxDate value must be provided in the ISO date format (yyyy-MM-dd)."
+        },
+        "minDate": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the minimum date available for selection.\n\n**Note:** If the formatPattern property is not set, the minDate value must be provided in the ISO date format (yyyy-MM-dd)."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the open or closed state of the popover.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint, intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** When no placeholder is set, the format pattern is displayed as a placeholder.\nPassing an empty string as the value of this property will make the component appear empty - without placeholder or format pattern."
+        },
+        "primaryCalendarType": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
+            "value": [
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              },
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Sets a calendar type used for display.\nIf not set, the calendar type of the global configuration is used."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is displayed as read-only.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "secondaryCalendarType": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
+            "value": [
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              },
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the secondary calendar type.\nIf not set, the calendar will only show the primary calendar type."
+        },
+        "showClearIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a formatted date value."
+        },
+        "valueFormat": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, used for the value attribute.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<DateRangePickerDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "formatValue",
+          "description": "**Note:** The getter method is inherited and not supported. If called it will return an empty value. / readonly dateValue: Date | null; /** Promise that resolves to the currently selected date represented as a Local JavaScript Date instance. / readonly dateValueAsync: Promise<Date | null>; /** **Note:** The getter method is inherited and not supported. If called it will return an empty value. / readonly dateValueUTC: Date | null; /** Returns the end date of the currently selected range as JavaScript Date instance. / readonly endDateValue: Date | null; /** Formats a Java Script date object into a string representing a locale date according to the `formatPattern` property of the DatePicker instance",
+          "params": [
+            {
+              "name": "date",
+              "type": {
+                "name": "Date"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "string"
+          }
+        },
+        {
+          "name": "isInValidRange",
+          "description": "Checks if a date is between the minimum and maximum date.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        },
+        {
+          "name": "isValid",
+          "description": "Checks if a value is valid against the current date format of the DatePicker.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        },
+        {
+          "name": "isValidDisplayValue",
+          "description": "Checks if a value is valid against the current date format of the DatePicker.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        },
+        {
+          "name": "isValidValue",
+          "description": "Checks if a value is valid against the current date format of the DatePicker.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "input",
+          "description": "Used to style the input element. This part is forwarded to the underlying ui5-input element."
+        }
+      ]
+    },
+    "DateTimePicker": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `DateTimePicker` component alows users to select both date (day, month and year) and time (hours, minutes and seconds)\nand for the purpose it consists of input field and Date/Time picker.\n\n### Usage\n\nUse the `DateTimePicker` if you need a combined date and time input component.\nDon't use it if you want to use either date, or time value.\nIn this case, use the `DatePicker` or the `TimePicker` components instead.\n\nThe user can set date/time by:\n\n- using the calendar and the time selectors\n- typing in the input field\n\nProgrammatically, to set date/time for the `DateTimePicker`, use the `value` property\n\n### Formatting\n\nThe value entered by typing into the input field must fit to the used date/time format.\n\nSupported format options are pattern-based on Unicode LDML Date Format notation.\nFor more information, see [UTS #35: Unicode Locale Data Markup Language](https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table).\n\n**Example:** the following format `dd/MM/yyyy, hh:mm:ss aa`\ncorresponds the `13/04/2020, 03:16:16 AM` value.\n\nThe small 'h' defines \"12\" hours format and the \"aa\" symbols - \"AM/PM\" time periods.\n\n**Example:** the following format `dd/MM/yyyy, HH:mm:ss`\ncorresponds the `13/04/2020, 15:16:16` value.\n\nThe capital 'H' indicates \"24\" hours format.\n\n**Note:** If the `formatPattern` does NOT include time,\nthe `DateTimePicker` will fallback to the default time format according to the locale.\n\n**Note:** If no placeholder is set to the `DateTimePicker`,\nthe current `formatPattern` is displayed as a placeholder.\nIf another placeholder is needed, it must be set or in case no placeholder is needed - it can be set to an empty string.\n\n**Note:** If the user input does NOT match the `formatPattern`,\nthe `DateTimePicker` makes an attempt to parse it based on the\nlocale settings.\n\n### Responsive behavior\n\nThe `DateTimePicker` is responsive and fully adapts to all devices.\nFor larger screens, such as tablet or desktop, it is displayed as a popover, while\non phone devices, it is displayed full screen.\n\n\n\n__Note:__ This is a UI5 Web Component! [DateTimePicker UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/DateTimePicker) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DateTimePickerDomRef, DatePickerChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in correct format pattern and in valid range."
+              },
+              {
+                "name": "value",
+                "type": "string",
+                "description": "The submitted value."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DateTimePickerDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component's picker is closed.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DateTimePickerDomRef, DatePickerInputEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the component is changed at each key stroke.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in correct format pattern and in valid range."
+              },
+              {
+                "name": "value",
+                "type": "string",
+                "description": "The submitted value."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DateTimePickerDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component's picker is opened.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onValueStateChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DateTimePickerDomRef, DatePickerValueStateChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the value state of the component is updated internally.\nThe event is preventable, meaning that if it's default action is\nprevented, the component will not update the value state.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in correct format pattern and in valid range."
+              },
+              {
+                "name": "valueState",
+                "type": "string",
+                "description": "The new `valueState` that will be set."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the aria-label attribute for the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component."
+        },
+        "calendarWeekNumbering": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarWeekNumbering | \"Default\" | \"ISO_8601\" | \"MiddleEastern\" | \"WesternTraditional\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "The default calendar week numbering:\n\nThe framework determines the week numbering scheme; currently it is derived from the\nactive format locale. Future versions of ui5-webcomponents might select a different week numbering\nscheme."
+              },
+              {
+                "value": "\"ISO_8601\"",
+                "description": "Official calendar week numbering in most of Europe (ISO 8601 standard):\nMonday is first day of the week, the week containing January 4th is first week of the year."
+              },
+              {
+                "value": "\"MiddleEastern\"",
+                "description": "Official calendar week numbering in much of the Middle East (Middle Eastern calendar):\nSaturday is first day of the week, the week containing January 1st is first week of the year."
+              },
+              {
+                "value": "\"WesternTraditional\"",
+                "description": "Official calendar week numbering in the United States, Canada, Brazil, Israel, Japan, and\nother countries (Western traditional calendar):\nSunday is first day of the week, the week containing January 1st is first week of the year."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"ISO_8601\""
+              },
+              {
+                "value": "\"MiddleEastern\""
+              },
+              {
+                "value": "\"WesternTraditional\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines how to calculate calendar weeks and first day of the week.\nIf not set, the calendar will be displayed according to the currently set global configuration.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is displayed as disabled.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "displayFormat": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, displayed in the input field.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "formatPattern": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, displayed in the input field.\n@deprecated Use displayFormat and valueFormat instead"
+        },
+        "hideWeekNumbers": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the visibility of the week numbers column.\n\n**Note:** For calendars other than Gregorian,\nthe week numbers are not displayed regardless of what is set.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "maxDate": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the maximum date available for selection.\n\n**Note:** If the formatPattern property is not set, the maxDate value must be provided in the ISO date format (yyyy-MM-dd)."
+        },
+        "minDate": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the minimum date available for selection.\n\n**Note:** If the formatPattern property is not set, the minDate value must be provided in the ISO date format (yyyy-MM-dd)."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the open or closed state of the popover.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint, intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** When no placeholder is set, the format pattern is displayed as a placeholder.\nPassing an empty string as the value of this property will make the component appear empty - without placeholder or format pattern."
+        },
+        "primaryCalendarType": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
+            "value": [
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              },
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Sets a calendar type used for display.\nIf not set, the calendar type of the global configuration is used."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is displayed as read-only.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "secondaryCalendarType": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
+            "value": [
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              },
+              {
+                "value": "\"Gregorian\""
+              },
+              {
+                "value": "\"Islamic\""
+              },
+              {
+                "value": "\"Japanese\""
+              },
+              {
+                "value": "\"Buddhist\""
+              },
+              {
+                "value": "\"Persian\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the secondary calendar type.\nIf not set, the calendar will only show the primary calendar type."
+        },
+        "showClearIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a formatted date value."
+        },
+        "valueFormat": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, used for the value attribute.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<DateTimePickerDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "formatValue",
+          "description": "Currently selected date represented as a Local JavaScript Date instance. Note: this getter can only be reliably used after the component is fully defined. Use dateValueAsync which resolves only when this condition is met. / readonly dateValue: Date | null; /** Promise that resolves to the currently selected date represented as a Local JavaScript Date instance. / readonly dateValueAsync: Promise<Date | null>; /** Formats a Java Script date object into a string representing a locale date according to the `formatPattern` property of the DatePicker instance",
+          "params": [
+            {
+              "name": "date",
+              "type": {
+                "name": "Date"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "string"
+          }
+        },
+        {
+          "name": "isInValidRange",
+          "description": "Checks if a date is between the minimum and maximum date.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        },
+        {
+          "name": "isValid",
+          "description": "Checks if a value is valid against the current date format of the DatePicker.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        },
+        {
+          "name": "isValidDisplayValue",
+          "description": "Checks if a value is valid against the current date format of the DatePicker.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        },
+        {
+          "name": "isValidValue",
+          "description": "Checks if a value is valid against the current date format of the DatePicker.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "input",
+          "description": "Used to style the input element. This part is forwarded to the underlying ui5-input element."
+        }
+      ]
+    },
+    "Dialog": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Dialog` component is used to temporarily display some information in a\nsize-limited window in front of the regular app screen.\nIt is used to prompt the user for an action or a confirmation.\nThe `Dialog` interrupts the current app processing as it is the only focused UI element and\nthe main screen is dimmed/blocked.\nThe dialog combines concepts known from other technologies where the windows have\nnames such as dialog box, dialog window, pop-up, pop-up window, alert box, or message box.\n\nThe `Dialog` is modal, which means that a user action is required before it is possible to return to the parent window.\nTo open multiple dialogs, each dialog element should be separate in the markup. This will ensure the correct modal behavior. Avoid nesting dialogs within each other.\nThe content of the `Dialog` is fully customizable.\n\n### Structure\nA `Dialog` consists of a header, content, and a footer for action buttons.\nThe `Dialog` is usually displayed at the center of the screen.\nIts position can be changed by the user. To enable this, you need to set the property `draggable` accordingly.\n\n\n### Responsive Behavior\nThe `stretch` property can be used to stretch the `Dialog` to full screen. For better usability, it's recommended to stretch the dialog to full screen on phone devices.\n\n**Note:** When a `Bar` is used in the header or in the footer, you should remove the default dialog's paddings.\n\nFor more information see the sample \"Bar in Header/Footer\".\n\n### Keyboard Handling\n\n#### Basic Navigation\nWhen the `Dialog` has the `draggable` property set to `true` and the header is focused, the user can move the dialog\nwith the following keyboard shortcuts:\n\n- [Up] or [Down] arrow keys - Move the dialog up/down.\n- [Left] or [Right] arrow keys - Move the dialog left/right.\n\n#### Resizing\nWhen the `Dialog` has the `resizable` property set to `true` and the header is focused, the user can change the size of the dialog\nwith the following keyboard shortcuts:\n\n- [Shift] + [Up] or [Down] - Decrease/Increase the height of the dialog.\n- [Shift] + [Left] or [Right] - Decrease/Increase the width of the dialog.\n\n\n\n__Note:__ This is a UI5 Web Component! [Dialog UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Dialog) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the Popup.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "footer": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the footer HTML Element.\n\n**Note:** When a `Bar` is used in the footer, you should remove the default dialog's paddings.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header HTML Element.\n\n**Note:** When a `Bar` is used in the header, you should remove the default dialog's paddings.\n\n**Note:** If `header` slot is provided, the labelling of the dialog is a responsibility of the application developer.\n`accessibleName` should be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onBeforeClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "escPressed",
+                "type": "boolean",
+                "description": "Indicates that `ESC` key has triggered the event."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onBeforeOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "PopupAccessibleRole | \"None\" | \"Dialog\" | \"AlertDialog\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "Represents no ARIA role."
+              },
+              {
+                "value": "\"Dialog\"",
+                "description": "Represents the ARIA role \"dialog\"."
+              },
+              {
+                "value": "\"AlertDialog\"",
+                "description": "Represents the ARIA role \"alertdialog\"."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Dialog\""
+              },
+              {
+                "value": "\"AlertDialog\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Dialog\""
+          }
+        },
+        "draggable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is draggable.\nIf this property is set to true, the Dialog will be draggable by its header.\n\n**Note:** The component can be draggable only in desktop mode.\n\n**Note:** This property overrides the default HTML \"draggable\" attribute native behavior.\nWhen \"draggable\" is set to true, the native browser \"draggable\"\nbehavior is prevented and only the Dialog custom logic (\"draggable by its header\") works.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text.\n\n**Note:** If `header` slot is provided, the `headerText` is ignored."
+        },
+        "initialFocus": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the ID of the HTML Element, which will get the initial focus.\n\n**Note:** If an element with `autofocus` attribute is added inside the component,\n`initialFocus` won't take effect."
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if the element is open\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "preventFocusRestore": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "preventInitialFocus": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "resizable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Configures the component to be resizable.\nIf this property is set to true, the Dialog will have a resize handle in its bottom right corner in LTR languages.\nIn RTL languages, the resize handle will be placed in the bottom left corner.\n\n**Note:** The component can be resizable only in desktop mode.\n\n**Note:** Upon resizing, externally defined height and width styling will be ignored.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "state": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the state of the `Dialog`.\n\n**Note:** If `\"Negative\"` and `\"Critical\"` states is set, it will change the\naccessibility role to \"alertdialog\", if the accessibleRole property is set to `\"Dialog\"`.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "stretch": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines if the dialog will be stretched to full screen on mobile. On desktop,\nthe dialog will be stretched to approximately 90% of the viewport.\n\n**Note:** For better usability of the component it is recommended to set this property to \"true\" when the dialog is opened on phone.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<DialogDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "applyFocus",
+          "description": "Focuses the element denoted by `initialFocus`, if provided, or the first focusable element otherwise.",
+          "params": [],
+          "returns": {
+            "type": "Promise<void>"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "content",
+          "description": "Used to style the content of the component"
+        },
+        {
+          "name": "footer",
+          "description": "Used to style the footer of the component"
+        },
+        {
+          "name": "header",
+          "description": "Used to style the header of the component"
+        }
+      ]
+    },
+    "DynamicDateRange": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `DynamicDateRange` component provides a flexible interface to define date ranges using a combination of absolute dates, relative intervals, and preset ranges (e.g., \"Today\", \"Yesterday\", etc.).\nIt allows users to select a date range from a predefined set of options or enter custom dates.\n\n### Usage\n\nThe component is typically used in scenarios where users need to filter data based on date ranges, such as in reports, dashboards, or data analysis tools.\nIt can be used with the predefined options or extended with custom options to suit specific requirements. You can create your own options by extending the `IDynamicDateRangeOption` interface.\nEvery option should be registered using the `DynamicDateRange.register` method.\n\nIf needed, you can also create a range of dates based on specific option using the `toDates` method.\n\n### Standard Options\n\nThe component comes with a set of standard options, including:\n- \"TODAY\" - Represents the current date. An example value is `{ operator: \"TODAY\"}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/Today.js\";`\n- \"YESTERDAY\" - Represents the previous date. An example value is `{ operator: \"YESTERDAY\"}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/Yesterday.js\";`\n- \"TOMORROW\" - Represents the next date. An example value is `{ operator: \"TOMORROW\"}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/Tomorrow.js\";`\n- \"DATE\" - Represents a single date. An example value is `{ operator: \"DATE\", values: [new Date()]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/SingleDate.js\";`\n- \"DATERANGE\" - Represents a range of dates. An example value is `{ operator: \"DATERANGE\", values: [new Date(), new Date()]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/DateRange.js\";`\n- \"DATETIMERANGE\" - Represents a range of dates with times. An example value is `{ operator: \"DATETIMERANGE\", values: [new Date(), new Date()]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/DateTimeRange.js\";`\n- \"FROMDATETIME\" - Represents a range from date and time. An example value is `{ operator: \"FROMDATETIME\", values: [new Date()]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/FromDateTime.js\";`\n- \"TODATETIME\" - Represents a range to date and time. An example value is `{ operator: \"TODATETIME\", values: [new Date()]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/ToDateTime.js\";`\n- \"LASTDAYS\" - Represents Last X Days from today. An example value is `{ operator: \"LASTDAYS\", values: [2]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/LastOptions.js\";`\n- \"LASTWEEKS\" - Represents Last X Weeks from today. An example value is `{ operator: \"LASTWEEKS\", values: [3]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/LastOptions.js\";`\n- \"LASTMONTHS\" - Represents Last X Months from today. An example value is `{ operator: \"LASTMONTHS\", values: [6]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/LastOptions.js\";`\n- \"LASTQUARTERS\" - Represents Last X Quarters from today. An example value is `{ operator: \"LASTQUARTERS\", values: [2]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/LastOptions.js\";`\n- \"LASTYEARS\" - Represents Last X Years from today. An example value is `{ operator: \"LASTYEARS\", values: [1]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/LastOptions.js\";`\n- \"NEXTDAYS\" - Represents Next X Days from today. An example value is `{ operator: \"NEXTDAYS\", values: [2]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/NextOptions.js\";`\n- \"NEXTWEEKS\" - Represents Next X Weeks from today. An example value is `{ operator: \"NEXTWEEKS\", values: [3]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/NextOptions.js\";`\n- \"NEXTMONTHS\" - Represents Next X Months from today. An example value is `{ operator: \"NEXTMONTHS\", values: [6]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/NextOptions.js\";`\n- \"NEXTQUARTERS\" - Represents Next X Quarters from today. An example value is `{ operator: \"NEXTQUARTERS\", values: [2]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/NextOptions.js\";`\n- \"NEXTYEARS\" - Represents Next X Years from today. An example value is `{ operator: \"NEXTYEARS\", values: [1]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/NextOptions.js\";`\n\n\n\n__Note:__ This is a UI5 Web Component! [DynamicDateRange UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/DynamicDateRange) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DynamicDateRangeDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter or on focusout or a value is selected in the popover.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "options": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the options listed as a string, separated by commas and using capital case.\nExample: \"TODAY, YESTERDAY, DATERANGE\""
+        },
+        "value": {
+          "type": {
+            "name": "DynamicDateRangeValue"
+          },
+          "required": false,
+          "description": "Defines the value object."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<DynamicDateRangeDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "toDates",
+          "description": "Converts a `value` into concrete `startDate` and `endDate` JavaScript `Date` objects.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "DynamicDateRangeValue"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "Array<Date>"
+          }
+        }
+      ]
+    },
+    "DynamicPage": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A layout component, representing a web page, consisting of a title, header with dynamic behavior, a content area, and an optional floating footer.\n\nThe component consist of several components:\n\n- `DynamicPageTitle` - a component, holding the title of the page, the navigation actions and the content. The displayed content changes based on the current mode of the `DynamicPageHeader`.\n- `DynamicPageHeader` - a generic container, which can contain a single layout component and any other HTML elements. The header works in two modes - expanded and snapped and its behavior can be adjusted with the help of different properties.\n- `Content area` - a generic container, which can have a single UI5 layout.\n- `Footer` - positioned at the bottom with a small offset and used for additional actions, the footer floats above the content.\n\n### Usage\n\nUse the `DynamicPage` if you need to have a title, that is always visible\nand a header, that has configurable Expanding/Snapping functionality.\nIf you don't need the Expanding/Snapping functionality it is better to use the\n`Page` as a lighter component.\n\nThe app can add to the `default` slot of the ui5-dynamic-page either content that is designed to fit its container (e.g. has 100% height),\nor content with own height that may overflow its container. In the second case the `DynamicPage` will show a scrollbar that allows the user\nscroll through the content.\n\n## Notes:\n\n- Snapping of the `DynamicPageTitle` is not supported in the following case:\n - When the `DynamicPage` has a scroll bar, the component usually scrolls to the snapping point - the point, where the `DynamicPageHeader` is scrolled out completely. However, when there is a scroll bar, but not enough content to reach the snapping point, the snapping is not possible using scrolling.\n\n### Responsive Behavior\n\nDynamic page web component implements the responsive paddings design.\n\n### Keyboard Handling\n\n\n### Basic Navigation\n\n- [SPACE, ENTER, RETURN] - If focus is on a button inside DynamicPageTitle its action is being triggered, once activated.\nIf focus is on the snap header button (arrow button), or on the header itself, once activated, it triggers the associated action (such as snap/expand the header).\nIf focus is on pin button (the button with pin icon on the bottom of the header), once activated, it triggers the associated action (pinning of the header).\n\n### Fast Navigation\n- This component provides a build in fast navigation group which can be used via `F6 / Shift + F6` or ` Ctrl + Alt(Option) + Down /  Ctrl + Alt(Option) + Up`.\nIn order to use this functionality, you need to import the following module:\n\n- `import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [DynamicPage UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/DynamicPage) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the Dynamic Page.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "footerArea": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the footer HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footerArea\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "headerArea": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"headerArea\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<DynamicPageHeader>`"
+        },
+        "titleArea": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the title HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"titleArea\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<DynamicPageTitle>`"
+        },
+        "onPinButtonToggle": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DynamicPageDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the pin header button is toggled.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onTitleToggle": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DynamicPageDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the expand/collapse area of the title is toggled.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "headerPinned": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the header is pinned.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "headerSnapped": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the header is snapped.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hidePinButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the pin button is hidden.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showFooter": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the footer is shown.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<DynamicPageDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "content",
+          "description": "Used to style the content of the component"
+        },
+        {
+          "name": "fit-content",
+          "description": "Used to style the fit content container of the component."
+        },
+        {
+          "name": "footer",
+          "description": "Used to style the footer of the component"
+        }
+      ]
+    },
+    "DynamicPageHeader": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Header of the DynamicPage.\n\nThe DynamicPageHeader `DynamicPageHeader` is part of the DynamicPage family\nand is used to serve as header of the `DynamicPage`.\n\n### Usage\n\nThe `DynamicPageHeader` can hold any layout control and has two states - expanded\nand collapsed (snapped). The switching between these states happens when:\n- the user scrolls below its bottom margin\n- the user clicks on the `DynamicPageTitle`\n- through the `DynamicPage` property `headerSnapped`\n\n### Responsive Behavior\n\nThe responsive behavior of the `DynamicPageHeader` depends on the behavior of the\ncontent that is displayed.\n\n### Accessibility\n\nThe `DynamicPageHeader` provides an accessible label for the header region.\n\n__Note:__ This is a UI5 Web Component! [DynamicPageHeader UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/DynamicPageHeader) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the Dynamic Page Header.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<DynamicPageHeaderDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "DynamicPageTitle": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Title of the `DynamicPage`.\n\nThe `DynamicPageTitle` component is part of the `DynamicPage`\nfamily and is used to serve as title of the `DynamicPage`.\n\n### Usage\n\nThe `DynamicPageTitle` can hold any component and displays the most important\ninformation regarding the object that will always remain visible while scrolling.\n\n**Note:** The `actions` slot accepts any UI5 web component, but it's\nrecommended to use `ui5-toolbar`.\n\nThe user can switch between the expanded/collapsed states of the\n`DynamicPage` by clicking on the `DynamicPageTitle`\nor by using the expand/collapse visual indicators, positioned at the bottom of the\n`DynamicPageTitle` and the `DynamicPageHeader` inside `DynamicPageHeaderActions`.\n\n### Responsive Behavior\n\nThe responsive behavior of the `DynamicPageTitle` depends on the behavior of the\ncontent that is displayed.\n\n__Note:__ This is a UI5 Web Component! [DynamicPageTitle UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/DynamicPageTitle) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "actionsBar": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the bar with actions in the Dynamic page title.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"actionsBar\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "breadcrumbs": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content of the breadcrumbs inside Dynamic Page Title.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"breadcrumbs\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the Dynamic page title.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "heading": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content of the Heading of the Dynamic Page.\n\nThe font size of the title within the `heading` slot can be adjusted to the recommended values using the following CSS variables:\n\n**Expanded:** `var(--sapObjectHeader_Title_FontSize)`\n\n**Collapsed:** `var(--sapObjectHeader_Title_SnappedFontSize)`\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"heading\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "navigationBar": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the bar with navigation actions in the Dynamic page title.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"navigationBar\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<Toolbar>`"
+        },
+        "snappedHeading": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the heading that is shown only when the header is snapped.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"snappedHeading\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "snappedSubheading": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content of the title that is shown only when the header is snapped.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"snappedSubheading\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "snappedTitleOnMobile": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content of the snapped title on mobile devices.\n\nThis slot is displayed only when the `DynamicPageTitle` is in the snapped state on mobile devices.\nIt should be used to provide a simplified, single-line title that takes up less space on smaller screens.\n\n**Note:**\n- The content set in this slot **overrides** all other content set in the `DynamicPageTitle` slots when displayed.\n- The slot is intended for a single `ui5-title` component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"snappedTitleOnMobile\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.3.0](https://github.com/UI5/webcomponents/releases/tag/v2.3.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<Title>`"
+        },
+        "subheading": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content of the title that is shown only when the header is not snapped.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"subheading\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<DynamicPageTitleDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "DynamicSideContent": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The DynamicSideContent (`DynamicSideContent`) is a layout component that allows additional content\nto be displayed in a way that flexibly adapts to different screen sizes. The side\ncontent appears in a container next to or directly below the main content\n(it doesn't overlay). When the side content is triggered, the main content becomes\nnarrower (if appearing side-by-side). The side content contains a separate scrollbar\nwhen appearing next to the main content.\n\n### Usage\n\n*When to use?*\n\nUse this component if you want to display relevant information that is not critical\nfor users to complete a task. Users should have access to all the key functions and\ncritical information in the app even if they do not see the side content. This is\nimportant because on smaller screen sizes it may be difficult to display the side\ncontent in a way that is easily accessible for the user.\n\n*When not to use?*\n\nDon't use it if you want to display navigation or critical information that prevents\nusers from completing a task when they have no access to the side content.\n\n### Responsive Behavior\n\nScreen width \\> 1440px\n\n- Main vs. side content ratio is 75 vs. 25 percent (with a minimum of 320px\neach).\n- If the application defines a trigger, the side content can be hidden.\n\nScreen width \\<\\= 1440px and \\> 1024px\n\n- Main vs. side content ratio is 66.666 vs. 33.333 percent (with a minimum of\n320px each). If the side content width falls below 320 px, it automatically slides\nunder the main content, unless the app development team specifies that it should\ndisappear.\n\nScreen width \\<\\= 1024px and \\> 720px\n\n- The side content ratio is fixed to 340px, and the main content takes the rest\nof the width. Only if the `sideContentFallDown` is set to `OnMinimumWidth`\nand screen width is \\<\\= 960px and \\> 720px the side content falls below the main content.\n\nScreen width \\<\\= 720px (for example on a mobile device)\n\n- In this case, the side content automatically disappears from the screen (unless\nspecified to stay under the content by setting of `sideContentVisibility`\nproperty to `AlwaysShow`) and can be triggered from a pre-set trigger\n(specified within the app). When the side content is triggered, it replaces the main\ncontent. We recommend that you always place the trigger for the side content in the\nsame location, such as in the app footer.\n\nA special case allows switching the comparison mode between the main and side content.\nIn this case, the screen is split into 50:50 percent for main vs. side content. The\nresponsive behavior of the equal split is the same as in the standard view - the\nside content disappears on screen widths of less than 720 px and can only be\nviewed by triggering it.\n\n\n\n__Note:__ This is a UI5 Web Component! [DynamicSideContent UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/DynamicSideContent) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the main content.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "sideContent": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the side content.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"sideContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onLayoutChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<DynamicSideContentDomRef, DynamicSideContentLayoutChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fires when the current breakpoint has been changed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "currentBreakpoint",
+                "type": "string",
+                "description": "the current breakpoint."
+              },
+              {
+                "name": "mainContentVisible",
+                "type": "boolean",
+                "description": "visibility of the main content."
+              },
+              {
+                "name": "previousBreakpoint",
+                "type": "string | undefined",
+                "description": "the breakpoint that was active before change to current breakpoint."
+              },
+              {
+                "name": "sideContentVisible",
+                "type": "boolean",
+                "description": "visibility of the side content."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "DynamicSideContentAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines additional accessibility attributes on different areas of the component.\n\nThe accessibilityAttributes object has the following fields:\n\n - **mainContent**: `mainContent.ariaLabel` defines the aria-label of the main content area. Accepts any string.\n - **sideContent**: `sideContent.ariaLabel` defines the aria-label of the side content area. Accepts any string.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "equalSplit": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in equal split mode. In this mode, the side and\nthe main content take 50:50 percent of the container on all screen sizes\nexcept for phone, where the main and side contents are switching visibility\nusing the toggle method.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideMainContent": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the visibility of the main content.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideSideContent": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the visibility of the side content.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "sideContentFallDown": {
+          "type": {
+            "name": "enum",
+            "raw": "SideContentFallDown | \"BelowXL\" | \"BelowL\" | \"BelowM\" | \"OnMinimumWidth\"",
+            "value": [
+              {
+                "value": "\"BelowXL\"",
+                "description": "Side content falls down on breakpoints below XL"
+              },
+              {
+                "value": "\"BelowL\"",
+                "description": "Side content falls down on breakpoints below L"
+              },
+              {
+                "value": "\"BelowM\"",
+                "description": "Side content falls down on breakpoints below M"
+              },
+              {
+                "value": "\"OnMinimumWidth\"",
+                "description": "Side content falls down on breakpoint M and the minimum width for the side content"
+              },
+              {
+                "value": "\"BelowXL\""
+              },
+              {
+                "value": "\"BelowL\""
+              },
+              {
+                "value": "\"BelowM\""
+              },
+              {
+                "value": "\"OnMinimumWidth\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines on which breakpoints the side content falls down below the main content.",
+          "defaultValue": {
+            "value": "\"OnMinimumWidth\""
+          }
+        },
+        "sideContentPosition": {
+          "type": {
+            "name": "enum",
+            "raw": "SideContentPosition | \"End\" | \"Start\"",
+            "value": [
+              {
+                "value": "\"End\"",
+                "description": "The side content is on the right side of the main container\nin left-to-right mode and on the left side in right-to-left mode."
+              },
+              {
+                "value": "\"Start\"",
+                "description": "The side content is on the left side of the main container\nin left-to-right mode and on the right side in right-to-left mode."
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Start\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines whether the side content is positioned before the main content (left side\nin LTR mode), or after the the main content (right side in LTR mode).",
+          "defaultValue": {
+            "value": "\"End\""
+          }
+        },
+        "sideContentVisibility": {
+          "type": {
+            "name": "enum",
+            "raw": "SideContentVisibility | \"AlwaysShow\" | \"ShowAboveL\" | \"ShowAboveM\" | \"ShowAboveS\" | \"NeverShow\"",
+            "value": [
+              {
+                "value": "\"AlwaysShow\"",
+                "description": "Show the side content on any breakpoint"
+              },
+              {
+                "value": "\"ShowAboveL\"",
+                "description": "Show the side content on XL breakpoint"
+              },
+              {
+                "value": "\"ShowAboveM\"",
+                "description": "Show the side content on L and XL breakpoints"
+              },
+              {
+                "value": "\"ShowAboveS\"",
+                "description": "Show the side content on M, L and XL breakpoints"
+              },
+              {
+                "value": "\"NeverShow\"",
+                "description": "Don't show the side content on any breakpoints"
+              },
+              {
+                "value": "\"AlwaysShow\""
+              },
+              {
+                "value": "\"ShowAboveL\""
+              },
+              {
+                "value": "\"ShowAboveM\""
+              },
+              {
+                "value": "\"ShowAboveS\""
+              },
+              {
+                "value": "\"NeverShow\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines on which breakpoints the side content is visible.",
+          "defaultValue": {
+            "value": "\"ShowAboveS\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<DynamicSideContentDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "toggleContents",
+          "description": "Toggles visibility of main and side contents on S screen size (mobile device).",
+          "params": [],
+          "returns": {
+            "type": "void"
+          }
+        }
+      ]
+    },
+    "ExpandableText": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ExpandableText` component allows displaying a large body of text in a small space. It provides an \"expand/collapse\" functionality, which shows/hides potentially truncated text.\n\n### Usage\n\n#### When to use:\n- To accommodate long texts in limited space, for example in list items, table cell texts, or forms\n\n#### When not to use:\n- The content is critical for the user. In this case use short descriptions that can fit in\n- Strive to provide short and meaningful texts to avoid excessive number of \"Show More\" links on the page\n\n### Responsive Behavior\n\nOn phones, if the component is configured to display the full text in a popover, the popover will appear in full screen.\n\n__Note:__ For compatibility reasons, `children`, `showOverflowInPopover`, and `renderWhitespace` are added by the UI5 Web Components for React wrapper and are not part of the underlying web component (`ui5-expandable-text`).\nThese props will be removed in the next major release (not yet planned); see their deprecation notices for alternatives.\n\n__Note:__ This is a UI5 Web Component! [ExpandableText UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ExpandableText) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "emptyIndicatorMode": {
+          "type": {
+            "name": "enum",
+            "raw": "TextEmptyIndicatorMode | \"Off\" | \"On\"",
+            "value": [
+              {
+                "value": "\"Off\"",
+                "description": "Empty indicator is never rendered."
+              },
+              {
+                "value": "\"On\"",
+                "description": "Empty indicator is rendered always when the component's content is empty."
+              },
+              {
+                "value": "\"Off\""
+              },
+              {
+                "value": "\"On\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Specifies if an empty indicator should be displayed when there is no text.",
+          "defaultValue": {
+            "value": "\"Off\""
+          }
+        },
+        "maxCharacters": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Maximum number of characters to be displayed initially. If the text length exceeds this limit, the text will be truncated with an ellipsis, and the \"More\" link will be displayed.",
+          "defaultValue": {
+            "value": "100"
+          }
+        },
+        "overflowMode": {
+          "type": {
+            "name": "enum",
+            "raw": "ExpandableTextOverflowMode | \"InPlace\" | \"Popover\"",
+            "value": [
+              {
+                "value": "\"InPlace\"",
+                "description": "Overflowing text is appended in-place."
+              },
+              {
+                "value": "\"Popover\"",
+                "description": "Full text is displayed in a popover."
+              },
+              {
+                "value": "\"InPlace\""
+              },
+              {
+                "value": "\"Popover\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines how the full text will be displayed.",
+          "defaultValue": {
+            "value": "\"InPlace\""
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Text of the component."
+        },
+        "children": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Text of the component.\n@deprecated : Please use `text` instead."
+        },
+        "showOverflowInPopover": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines if the full text should be displayed inside a `ResponsivePopover` or in-place.\n@deprecated : Please use `overflowMode` instead."
+        },
+        "renderWhitespace": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines how white-space inside <code>Text</code> is handled. If set to true, sequences of white space are preserved."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ExpandableTextDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "FileUploader": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `FileUploader` opens a file explorer dialog and enables users to upload files.\nThe component consists of input field, but you can provide an HTML element by your choice\nto trigger the file upload, by using the default slot.\nFurthermore, you can set the property \"hideInput\" to \"true\" to hide the input field.\n\nTo get all selected files, you can simply use the read-only \"files\" property.\nTo restrict the types of files the user can select, you can use the \"accept\" property.\n\nAnd, similar to all input based components, the FileUploader supports \"valueState\", \"placeholder\", \"name\", and \"disabled\" properties.\n\nFor the `FileUploader`\n\n\n__Note:__ This is a UI5 Web Component! [FileUploader UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/FileUploader) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "This slot allows you to add custom content to the component, such as a button or any other interactive element to trigger the file selection dialog.\n\n**Note:** For best accessibility experience, set a `tabindex` of \"-1\" on your interactive element, or it will be set automatically.\nThis slot is intended for use cases where you want a button-only file uploader.\nIt is recommended to set `hideInput` property to \"true\" when using this slot.\nNot setting `hideInput` may negatively impact the screen reader users.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<FileUploaderDomRef, FileUploaderChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Event is fired when the value of the file path has been changed.\n\n**Note:** Keep in mind that because of the HTML input element of type file, the event is also fired in Chrome browser when the Cancel button of the uploads window is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "files",
+                "type": "FileList | null",
+                "description": "The current files."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onFileSizeExceed": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<FileUploaderDomRef, FileUploaderFileSizeExceedEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Event is fired when the size of a file is above the `maxFileSize` property value.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "filesData",
+                "type": "Array<FileData>",
+                "description": "An array of `FileData` objects containing the`fileName` and `fileSize` in MB of each file that exceeds the upload limit."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accept": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Comma-separated list of file types that the component should accept.\n\n**Note:** Please make sure you are adding the `.` in front on the file type, e.g. `.png` in case you want to accept png's only."
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the input.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideInput": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "If set to \"true\", the input field of component will not be rendered. Only the default slot that is passed will be rendered.\n\n**Note:** Use this property in combination with the default slot to achieve a button-only file uploader design.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "maxFileSize": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the maximum file size in megabytes which prevents the upload if at least one file exceeds it.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**."
+        },
+        "multiple": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Allows multiple files to be chosen.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint intended to aid the user with data entry when the component has no value."
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the name/names of the file/files to upload."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<FileUploaderDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "FilterItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `FilterItem` component defines the filtering criteria for data in `ViewSettingsDialog`.\nIt represents a single filter category that contains multiple filter options that users can select.\n\n### Usage\n\nThe `FilterItem` is used within the `ViewSettingsDialog` to provide filtering options.\n\n\n\n__Note:__ This is a UI5 Web Component! [FilterItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/FilterItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "values": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the filter options available for this filter category.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"values\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<FilterItemOption>`"
+        },
+        "additionalText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the additional text of the filter item.\nThis text is typically used to show the number of selected filter options within this category."
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the filter item."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<FilterItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "FilterItemOption": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `FilterItemOption` component defines individual filter values within a `FilterItem`.\nIt represents a single selectable option that users can choose to filter data.\n\n### Usage\n\nThe `FilterItemOption` is used as a child component within `FilterItem` in the context\nof `ViewSettingsDialog`. Each option represents a specific value that can be used for filtering\n\n\n\n__Note:__ This is a UI5 Web Component! [FilterItemOption UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/FilterItemOption) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the filter option is selected.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the filter option."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<FilterItemOptionDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "FlexibleColumnLayout": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `FlexibleColumnLayout` implements the list-detail-detail paradigm by displaying up to three pages in separate columns.\nThere are several possible layouts that can be changed either with the component API, or by dragging the column separators.\n\n### Usage\n\nUse this component for applications that need to display several logical levels of related information side by side (e.g. list of items, item, sub-item, etc.).\nThe Component is flexible in a sense that the application can focus the user's attention on one particular column.\n\n### Responsive Behavior\n\nThe `FlexibleColumnLayout` automatically displays the maximum possible number of columns based on `layout` property and the window size.\nThe component would display 1 column for window size smaller than 599px, up to two columns between 599px and 1023px,\nand 3 columns for sizes bigger than 1023px.\n\n**Note:** When the component displays more than one column, the minimal width of each column is 248px. Consequently, when the user drags a column separator to resize the columns, the minimal allowed width of any resized column is 248px.\n\n### Keyboard Handling\n\n#### Basic Navigation\n\nWhen a column separator is focused,  the following keyboard\nshortcuts allow the user to resize the columns and change the layout:\n\n- [Shift] + [Left] or [Shift] + [Right] - Moves the separator to the left or right, which resizes the columns accordingly.\n- [Left] or [Right] - Moves the separator to the left or right with a bigger step, which resizes the columns accordingly.\n- [Home] - Moves the separator to the start position.\n- [End] - Moves the separator to the end position.\n- This component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [FlexibleColumnLayout UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/FlexibleColumnLayout) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "endColumn": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content in the end column.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"endColumn\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "midColumn": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content in the middle column.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"midColumn\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "startColumn": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content in the start column.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"startColumn\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onLayoutChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<FlexibleColumnLayoutDomRef, FlexibleColumnLayoutLayoutChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the layout changes via user interaction by dragging the separators\nor by changing the component size due to resizing.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "columnLayout",
+                "type": "array",
+                "description": "The effective column layout, f.e [67%, 33%, 0]"
+              },
+              {
+                "name": "endColumnVisible",
+                "type": "boolean",
+                "description": "Indicates if the end column is currently visible"
+              },
+              {
+                "name": "layout",
+                "type": "FCLLayout",
+                "description": "The current layout"
+              },
+              {
+                "name": "midColumnVisible",
+                "type": "boolean",
+                "description": "Indicates if the middle column is currently visible"
+              },
+              {
+                "name": "resized",
+                "type": "boolean",
+                "description": "Indicates if the layout was changed by resizing the entire component"
+              },
+              {
+                "name": "separatorsUsed",
+                "type": "boolean",
+                "description": "Indicates if the layout was changed by dragging the column separators"
+              },
+              {
+                "name": "startColumnVisible",
+                "type": "boolean",
+                "description": "Indicates if the start column is currently visible"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onLayoutConfigurationChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<FlexibleColumnLayoutDomRef, FlexibleColumnLayoutLayoutConfigurationChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `layoutsConfiguration` changes via user interaction by dragging the separators.\n\n**Note:** The `layout-configuration-change` event is in an experimental state and is a subject to change.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "columnLayout",
+                "type": "array",
+                "description": "The effective column layout, f.e [\"67%\", \"33%\", \"0px\"]"
+              },
+              {
+                "name": "layout",
+                "type": "FCLLayout",
+                "description": "The current layout"
+              },
+              {
+                "name": "media",
+                "type": "MEDIA",
+                "description": "The current media type"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "FCLAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines additional accessibility attributes on different areas of the component.\n\nThe accessibilityAttributes object has the following fields,\nwhere each field is an object supporting one or more accessibility attributes:\n\n - **startColumn**: `startColumn.role` and `startColumn.name`.\n - **midColumn**: `midColumn.role` and `midColumn.name`.\n - **endColumn**: `endColumn.role` and `endColumn.name`.\n - **startSeparator**: `startSeparator.role` and `startSeparator.name`.\n - **endSeparator**: `endSeparator.role` and `endSeparator.name`.\n\nThe accessibility attributes support the following values:\n\n- **role**: Defines the accessible ARIA landmark role of the area.\nAccepts the following values: `none`, `complementary`, `contentinfo`, `main` or `region`.\n\n- **name**: Defines the accessible ARIA name of the area.\nAccepts any string.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "disableResizing": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Specifies if the user is allowed to change the columns layout by dragging the separator between the columns.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "layout": {
+          "type": {
+            "name": "enum",
+            "raw": "FCLLayout | \"OneColumn\" | \"TwoColumnsStartExpanded\" | \"TwoColumnsMidExpanded\" | \"ThreeColumnsMidExpanded\" | \"ThreeColumnsEndExpanded\" | \"ThreeColumnsStartExpandedEndHidden\" | ... 4 more ... | \"EndColumnFullScreen\"",
+            "value": [
+              {
+                "value": "\"OneColumn\"",
+                "description": "The layout will display 1 column."
+              },
+              {
+                "value": "\"TwoColumnsStartExpanded\"",
+                "description": "\nDesktop: Defaults to 67 - 33 - -- percent widths of columns. Start (expanded) and Mid columns are displayed.\nTablet:  Defaults to 67 - 33 - -- percent widths of columns. Start (expanded) and Mid columns are displayed.\nPhone:   Fixed -- 100 -- percent widths of columns, only the Mid column is displayed\n\nUse to display both a list and a detail page when the user should focus on the list page."
+              },
+              {
+                "value": "\"TwoColumnsMidExpanded\"",
+                "description": "Desktop: Defaults to 33 - 67 - -- percent widths of columns. Start and Mid (expanded) columns are displayed\nTablet:  Defaults to 33 - 67 - -- percent widths of columns. Start and Mid (expanded) columns are displayed\nPhone:   Fixed -- 100 -- percent widths of columns, only the Mid column is displayed\n\nUse to display both a list and a detail page when the user should focus on the detail page."
+              },
+              {
+                "value": "\"ThreeColumnsMidExpanded\"",
+                "description": "Desktop: Defaults to 25 - 50 - 25 percent widths of columns. Start, Mid (expanded) and End columns are displayed\nTablet:  Defaults to 0 - 67 - 33 percent widths of columns. Mid (expanded) and End columns are displayed, Start is accessible by dragging the columns-separator\nPhone:   Fixed -- -- 100 percent widths of columns, only the End column is displayed\n\nUse to display all three pages (list, detail, detail-detail) when the user should focus on the detail."
+              },
+              {
+                "value": "\"ThreeColumnsEndExpanded\"",
+                "description": "Desktop: Defaults to 25 - 25 - 50 percent widths of columns. Start, Mid and End (expanded) columns are displayed\nTablet:  Defaults to 0 - 33 - 67 percent widths of columns. Mid and End (expanded) columns are displayed, Start is accessible by dragging the columns-separator\nPhone:   Fixed -- -- 100 percent widths of columns (only the End column is displayed)\n\nUse to display all three pages (list, detail, detail-detail) when the user should focus on the detail-detail."
+              },
+              {
+                "value": "\"ThreeColumnsStartExpandedEndHidden\"",
+                "description": "Desktop: Defaults to 67 - 33 - 0 percent widths of columns. Start (expanded) and Mid columns are displayed, End is accessible by dragging the columns-separator\nTablet:  Defaults to 67 - 33 - 0 percent widths of columns. Start (expanded) and Mid columns are displayed, End is accessible by dragging the columns-separator\nPhone:   Fixed -- -- 100 percent widths of columns, only the End column is displayed\n\nUse to display the list and detail pages when the user should focus on the list.\nThe detail-detail is still loaded and easily accessible by dragging the columns-separator"
+              },
+              {
+                "value": "\"ThreeColumnsMidExpandedEndHidden\"",
+                "description": "Desktop: Defaults to 33 - 67 - 0 percent widths of columns. Start and Mid (expanded) columns are displayed, End is accessible by dragging the columns-separator\nTablet:  Defaults to 33 - 67 - 0 percent widths of columns. Start and Mid (expanded) columns are displayed, End is accessible by dragging the columns-separator\nPhone:   Fixed -- -- 100 percent widths of columns, only the End column is displayed\n\nUse to display the list and detail pages when the user should focus on the detail.\nThe detail-detail is still loaded and easily accessible by dragging the columns-separator"
+              },
+              {
+                "value": "\"ThreeColumnsStartHiddenMidExpanded\"",
+                "description": "Desktop: Defaults to 0 - 67 - 33 percent widths of columns. Start is hidden, Mid (expanded) and End columns are displayed.\nTablet:  Defaults to 0 - 67 - 33 percent widths of columns. Start is hidden, Mid (expanded) and End columns are displayed.\nPhone:   Fixed -- 100 percent width of the Mid column, only the Mid column is displayed.\n\nUse to display the Mid and End columns while the Start column is hidden."
+              },
+              {
+                "value": "\"ThreeColumnsStartHiddenEndExpanded\"",
+                "description": "Desktop: Defaults to 0 - 33 - 67 percent widths of columns. Start is hidden, Mid and End (expanded) columns are displayed.\nTablet:  Defaults to 0 - 33 - 67 percent widths of columns. Start is hidden, Mid and End (expanded) columns are displayed.\nPhone:   Fixed -- 100 percent width of the End column, only the End column is displayed.\n\nUse to display the Mid column and expanded End column while the grip of the separator is not visible."
+              },
+              {
+                "value": "\"MidColumnFullScreen\"",
+                "description": "Desktop: Fixed -- 100 -- percent widths of columns, only the Mid column is displayed\nTablet:  Fixed -- 100 -- percent widths of columns, only the Mid column is displayed\nPhone:   Fixed -- 100 -- percent widths of columns, only the Mid column is displayed\n\nUse to display a detail page only, when the user should focus entirely on it."
+              },
+              {
+                "value": "\"EndColumnFullScreen\"",
+                "description": "Desktop: Fixed -- -- 100 percent widths of columns, only the End column is displayed\nTablet:  Fixed -- -- 100 percent widths of columns, only the End column is displayed\nPhone:   Fixed -- -- 100 percent widths of columns, only the End column is displayed\n\nUse to display a detail-detail page only, when the user should focus entirely on it."
+              },
+              {
+                "value": "\"OneColumn\""
+              },
+              {
+                "value": "\"TwoColumnsStartExpanded\""
+              },
+              {
+                "value": "\"TwoColumnsMidExpanded\""
+              },
+              {
+                "value": "\"ThreeColumnsMidExpanded\""
+              },
+              {
+                "value": "\"ThreeColumnsEndExpanded\""
+              },
+              {
+                "value": "\"ThreeColumnsStartExpandedEndHidden\""
+              },
+              {
+                "value": "\"ThreeColumnsMidExpandedEndHidden\""
+              },
+              {
+                "value": "\"ThreeColumnsStartHiddenMidExpanded\""
+              },
+              {
+                "value": "\"ThreeColumnsStartHiddenEndExpanded\""
+              },
+              {
+                "value": "\"MidColumnFullScreen\""
+              },
+              {
+                "value": "\"EndColumnFullScreen\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the columns layout and their proportion.\n\n**Note:** The layout also depends on the screen size - one column for screens smaller than 599px,\ntwo columns between 599px and 1023px and three columns for sizes bigger than 1023px.\n\n**For example:** layout=`TwoColumnsStartExpanded` means the layout will display up to two columns\nin 67%/33% proportion.",
+          "defaultValue": {
+            "value": "\"OneColumn\""
+          }
+        },
+        "layoutsConfiguration": {
+          "type": {
+            "name": "LayoutConfiguration"
+          },
+          "required": false,
+          "description": "Allows to customize the column proportions per screen size and layout.\nIf no custom proportion provided for a specific layout, the default will be used.\n\n**Notes:**\n\n- The proportions should be given in percentages. For example [\"30%\", \"40%\", \"30%\"], [\"70%\", \"30%\", 0], etc.\n- The proportions should add up to 100%.\n- Hidden columns are marked as \"0px\", e.g. [\"0px\", \"70%\", \"30%\"]. Specifying 0 or \"0%\" for hidden columns is also valid.\n- If the proportions do not match the layout (e.g. if provided proportions [\"70%\", \"30%\", \"0px\"] for \"OneColumn\" layout), then the default proportions will be used instead.\n- Whenever the user drags the columns separator to resize the columns, the `layoutsConfiguration` object will be updated with the user-specified proportions for the given layout (and the `layout-configuration-change` event will be fired).\n- No custom configuration available for the phone screen size, as the default of 100% column width is always used there.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<FlexibleColumnLayoutDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Form": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The Form is a layout component that arranges labels and form fields (like input fields) pairs\ninto a specific number of columns.\n\n**Note:** The Form web component is a layout component, it isn't a replacement for the native `form` HTML element.\nThe Form web component does not provide any APIs for form submission.\n\n### Structure\n\n- **Form** (`Form`) is the top-level container component, responsible for the content layout and responsiveness.\n- **FormGroup** (`FormGroup`) enables the grouping of the Form content.\n- **FormItem** (`FormItem`) is a pair of label and form fields and can be used directly in a Form, or as part of a FormGroup.\n\nThe simplest Form (`Form`) consists of a header area on top,\ndisplaying a header text (see the `headingText` property) and content below - an arbitrary number of FormItems (ui5-form-item),\nrepresenting the pairs of label and form fields.\n\nAnd, there is also \"grouping\" available to assist the implementation of richer UIs.\nThis is enabled by the FormGroup (`FormGroup`) component.\nIn this case, the Form is structured into FormGroups and each FormGroup consists of FormItems.\n\n### Responsiveness\n\nThe Form component reacts and changes its layout on predefined breakpoints.\nDepending on its size, the Form content (FormGroups and FormItems) gets divided into one or more columns as follows:\n- **S** (< 600px) – 1 column is recommended (default: 1)\n- **M** (600px - 1022px) – up to 2 columns are recommended (default: 1)\n- **L** (1023px - 1439px) - up to 3 columns are recommended (default: 2)\n- **XL** (> 1439px) – up to 6 columns are recommended (default: 3)\n\nTo change the layout, use the `layout` property - f.e. layout=\"S1 M2 L3 XL6\".\n\n### Groups\n\nTo make better use of screen space, there is built-in logic to determine how many columns should a FormGroup occupy.\n\n- **Example #1** (perfect match):\n4 columns and 4 groups: each group will use 1 column.\n\n- **Example #2** (balanced distribution):\n4 columns and 2 groups: each group will use 2 columns.\n6 columns and 2 groups: each group will use 3 columns.\n\n- **Example #3** (unbalanced distribution):\n3 columns and 2 groups: the larger one will use 2 columns, the smaller 1 column.\n5 columns and 3 groups: two of the groups will use 2 columns each, the smallest 1 column.\n\n**Note:** The size of a group element is determined by the number of FormItems assigned to it.\nIn the case of equality, the first in the DOM will use more columns, and the last - fewer columns.\n\n- **Example #4** (more groups than columns):\n3 columns and 4 groups: each FormGroup uses only 1 column, the last FormGroup will wrap on the second row.\n\n### Groups Column Span\n\nTo influence the built-in group distribution, described in the previous section,\nyou can use the FormGroup's `columnSpan` property, that defines how many columns the group should expand to.\n\n### Items Column Span\n\nFormItem's columnSpan property defines how many columns the form item should expand to inside a form group or the form.\n\n### Items Label Span\n\nThe placement of the labels depends on the size of the used column.\nIf there is enough space, the labels are next to their associated fields, otherwise  - above the fields.\nBy default, the labels take 4/12 of the FormItem, leaving 8/12 parts to associated fields.\nYou can control what space the labels should take via the `labelSpan` property.\n\n**For example:** To always place the labels on top set: `labelSpan=\"S12 M12 L12 XL12\"` property.\n\n### Items Empty Span\n\nBy default, a form item spans 12 cells, fully divided between its label and field, with no empty space at the end:\n- **Label:** occupies 4 cells.\n- **Field:** occupies 8 cells.\n\nThe `emptySpan` property provides additional layout flexibility by defining empty space at the form item’s end.\n\n**For example:** Setting \"S0 M0 L3 XL3\" (or just \"L3 XL3\") adjusts the layout as follows:\n- **Label:** remains 4 cells.\n- **Field:** is reduced to 5 cells.\n- **Empty space:** 3 cells are added at the end.\n\nGreater values increase the empty space at the end of the form item, reducing the space available for the label and its field.\nHowever, setting `emptySpan` to 1 cell is recommended and typically sufficient to achieve a balanced layout.\n\n### Navigation flow\n\nThe Form component supports two layout options for keyboard navigation:\n\n#### Simple form\n\nIn this \"simple form\" layout, each `FormItem` acts as a standalone group\nwith one item, so focus moves horizontally across the grid from one `FormItem` to the next.\nThis layout is ideal for simpler forms and supports custom arrangements, e.g.,\n\n```\n| 1 | 2 |\n|   3   |\n| 4 | 5 |\n```\n\n#### Complex form\n\nIn this layout, items are grouped into `FormGroup` elements, allowing more complex configurations:\n\n- **Single-Column Group**: Focus moves vertically down from one item to the next.\n  ```\n  | 1 |\n  | 2 |\n  | 3 |\n  ```\n\n- **Multi-Column Group**: Focus moves horizontally within each row, advancing to the next row after completing the current one.\n  ```\n  | 1 | 4 |\n  | 2 | 5 |\n  | 3 | 6 |\n  ```\n\n### Keyboard Handling\n\n- [Tab] - Moves the focus to the next interactive element within the Form/FormGroup (if available) or to the next element in the tab chain outside the Form\n- [Shift] + [Tab] - Moves the focus to the previous interactive element within the Form/FormGroup (if available) or to the previous element in the tab chain outside the Form\n- [F6] - Moves the focus to the first interactive element of the next FormGroup (if available) or to the next element in the tab chain outside the Form\n- [Shift] + [F6] - Moves the focus to the first interactive element of the previous FormGroup (if available) or to the previous element in the tab chain outside the Form\n\n### ES6 Module Import\n\n- import\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the component content - FormGroups or FormItems.\n\n**Note:** Mixing FormGroups and standalone FormItems (not belonging to a group) is not supported.\nEither use FormGroups and make sure all FormItems are part of a FormGroup, or use just FormItems without any FormGroups.\n\n__Supported Node Type/s:__ `Array<IFormItem>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the component header area.\n\n**Note:** When a `header` is provided, the `headerText` property is ignored.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "accessibleMode": {
+          "type": {
+            "name": "enum",
+            "raw": "FormAccessibleMode | \"Display\" | \"Edit\"",
+            "value": [
+              {
+                "value": "\"Display\"",
+                "description": "Display mode."
+              },
+              {
+                "value": "\"Edit\"",
+                "description": "Edit mode."
+              },
+              {
+                "value": "\"Display\""
+              },
+              {
+                "value": "\"Edit\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the accessibility mode of the component in \"edit\" and \"display\" use-cases.\n\nBased on the mode, the component renders different HTML elements and ARIA attributes,\nwhich are appropriate for the use-case.\n\n**Usage:**\n- Set this property to \"Display\", when the form consists of non-editable (e.g. texts) form items.\n- Set this property to \"Edit\", when the form consists of editable (e.g. input fields) form items.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Display\""
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines id (or many ids) of the element (or elements) that label the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
+        },
+        "emptySpan": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the number of cells that are empty at the end of each form item, configurable by breakpoint.\n\nBy default, a form item spans 12 cells, fully divided between its label (4 cells) and field (8 cells), with no empty space at the end.\nThe `emptySpan` provides additional layout flexibility by defining empty space at the form item’s end.\n\n**Note:**\n- The maximum allowable empty space is 10 cells. At least 1 cell each must remain for the label and the field.\n- When `emptySpan` is specified (greater than 0), ensure that the combined value of `emptySpan` and `labelSpan` does not exceed 11. This guarantees a minimum of 1 cell for the field.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"S0 M0 L0 XL0\""
+          }
+        },
+        "headerLevel": {
+          "type": {
+            "name": "enum",
+            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
+            "value": [
+              {
+                "value": "\"H1\"",
+                "description": "Renders `h1` tag."
+              },
+              {
+                "value": "\"H2\"",
+                "description": "Renders `h2` tag."
+              },
+              {
+                "value": "\"H3\"",
+                "description": "Renders `h3` tag."
+              },
+              {
+                "value": "\"H4\"",
+                "description": "Renders `h4` tag."
+              },
+              {
+                "value": "\"H5\"",
+                "description": "Renders `h5` tag."
+              },
+              {
+                "value": "\"H6\"",
+                "description": "Renders `h6` tag."
+              },
+              {
+                "value": "\"H1\""
+              },
+              {
+                "value": "\"H2\""
+              },
+              {
+                "value": "\"H3\""
+              },
+              {
+                "value": "\"H4\""
+              },
+              {
+                "value": "\"H5\""
+              },
+              {
+                "value": "\"H6\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the compoennt heading level,\nset by the `headerText`.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"H2\""
+          }
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text of the component.\n\n**Note:** The property gets overridden by the `header` slot."
+        },
+        "itemSpacing": {
+          "type": {
+            "name": "enum",
+            "raw": "FormItemSpacing | \"Normal\" | \"Large\"",
+            "value": [
+              {
+                "value": "\"Normal\"",
+                "description": "Normal spacing (smaller vertical space between form items)."
+              },
+              {
+                "value": "\"Large\"",
+                "description": "Large spacing (larger vertical space between form items)."
+              },
+              {
+                "value": "\"Normal\""
+              },
+              {
+                "value": "\"Large\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the vertical spacing between form items.\n\n**Note:** If the Form is meant to be switched between \"display\"(\"non-edit\") and \"edit\" modes,\nwe recommend using \"Large\" item spacing in \"display\"(\"non-edit\") mode, and \"Normal\" - for \"edit\" mode,\nto avoid \"jumping\" effect, caused by the hight difference between texts in \"display\"(\"non-edit\") mode and the input fields in \"edit\" mode.",
+          "defaultValue": {
+            "value": "\"Normal\""
+          }
+        },
+        "labelSpan": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the width proportion of the labels and fields of a form item by breakpoint.\n\nBy default, the labels take 4/12 (or 1/3) of the form item in M,L and XL sizes,\nand 12/12 in S size, e.g in S the label is on top of its associated field.\n\nThe supported values are between 1 and 12. Greater the number, more space the label will use.\n\n**Note:** If \"12\" is set, the label will be displayed on top of its assosiated field.",
+          "defaultValue": {
+            "value": "\"S12 M4 L4 XL4\""
+          }
+        },
+        "layout": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the number of columns to distribute the form content by breakpoint.\n\nSupported values:\n- `S` - 1 column by default (1 column is recommended)\n- `M` - 1 column by default (up to 2 columns are recommended)\n- `L` - 2 columns by default (up to 3 columns are recommended)\n- `XL` - 3 columns by default (up to 6 columns  are recommended)",
+          "defaultValue": {
+            "value": "\"S1 M1 L2 XL3\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<FormDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "column",
+          "description": "Used to style a single column of the form column layout."
+        },
+        {
+          "name": "header",
+          "description": "Used to style the wrapper of the header."
+        },
+        {
+          "name": "layout",
+          "description": "Used to style the element defining the form column layout."
+        }
+      ]
+    },
+    "FormGroup": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The FormGroup (ui5-form-group) represents a group inside the Form (ui5-form) component\nand it consists of FormItem (ui5-form-item) components.\n\nThe layout of the FormGroup is mostly defined and controlled by the overarching Form (ui5-form) component.\nStill, one can influence the layout via the FormGroup's `columnSpan` property,\nthat defines how many columns the group should expand to.\n\n### Usage\n\nТhe FormGroup (ui5-form-group) allows to split a Form into groups,\ne.g to group FormItems that logically belong together.\n\n### ES6 Module Import\n\n- import\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the component.\n\n__Supported Node Type/s:__ `Array<FormItem>`"
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines id (or many ids) of the element (or elements) that label the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
+        },
+        "columnSpan": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines column span of the component,\ne.g how many columns the group should span to."
+        },
+        "headerLevel": {
+          "type": {
+            "name": "enum",
+            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
+            "value": [
+              {
+                "value": "\"H1\"",
+                "description": "Renders `h1` tag."
+              },
+              {
+                "value": "\"H2\"",
+                "description": "Renders `h2` tag."
+              },
+              {
+                "value": "\"H3\"",
+                "description": "Renders `h3` tag."
+              },
+              {
+                "value": "\"H4\"",
+                "description": "Renders `h4` tag."
+              },
+              {
+                "value": "\"H5\"",
+                "description": "Renders `h5` tag."
+              },
+              {
+                "value": "\"H6\"",
+                "description": "Renders `h6` tag."
+              },
+              {
+                "value": "\"H1\""
+              },
+              {
+                "value": "\"H2\""
+              },
+              {
+                "value": "\"H3\""
+              },
+              {
+                "value": "\"H4\""
+              },
+              {
+                "value": "\"H5\""
+              },
+              {
+                "value": "\"H6\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the compoennt heading level,\nset by the `headerText`.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"H3\""
+          }
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines header text of the component."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<FormGroupDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "FormItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The FormItem (ui5-form-item) represents pair of a label and\none or more components (text or text fields), associated to it.\n\n### Usage\n\nThe FormItem is being used in FormGroup (ui5-form-group) or directly in Form (ui5-form).\n\n### ES6 Module Import\n\n- import\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component,\nassociated to `labelContent`.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "labelContent": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the label of the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"labelContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "columnSpan": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the column span of the component,\ne.g how many columns the component should span to.\n\n**Note:** The column span should be a number between 1 and the available columns of the FormGroup (when items are placed in a group)\nor the Form. The available columns can be affected by the FormGroup#columnSpan and/or the Form#layout.\nA number bigger than the available columns won't take effect."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<FormItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "content",
+          "description": "Used to style the content part of the form item."
+        },
+        {
+          "name": "label",
+          "description": "Used to style the label part of the form item."
+        },
+        {
+          "name": "layout",
+          "description": "Used to style the parent element of the label and content parts."
+        }
+      ]
+    },
+    "GroupItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `GroupItem` component defines the grouping criteria for data in `ViewSettingsDialog`.\nIt represents a single group option that users can select to organize data into logical groups.\n\n### Usage\n\nThe `GroupItem` is used within the `ViewSettingsDialog` to provide grouping options.\nEach group item represents a column or field by which data can be grouped.\n\n\n\n__Note:__ This is a UI5 Web Component! [GroupItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/GroupItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the group item is selected.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the group item."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<GroupItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Icon": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Icon` component represents an SVG icon.\nThere are two main scenarios how the `Icon` component is used:\nas a purely decorative element,\nor as an interactive element that can be focused and clicked.\n\n### Usage\n\n1. **Get familiar with the icons collections.**\n\nBefore displaying an icon, you need to explore the icons collections to find and import the desired icon.\n\nCurrently there are 3 icons collection, available as 3 npm packages:\n\n- [@ui5/webcomponents-icons](https://www.npmjs.com/package/@ui5/webcomponents-icons) represents the \"SAP-icons\" collection and includes the following\n[icons](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html#/overview/SAP-icons).\n- [@ui5/webcomponents-icons-tnt](https://www.npmjs.com/package/@ui5/webcomponents-icons-tnt) represents the \"tnt\" collection and includes the following\n[icons](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html#/overview/SAP-icons-TNT).\n- [@ui5/webcomponents-icons-business-suite](https://www.npmjs.com/package/@ui5/webcomponents-icons-business-suite) represents the \"business-suite\" collection and includes the following\n[icons](https://ui5.sap.com/test-resources/sap/m/demokit/iconExplorer/webapp/index.html#/overview/BusinessSuiteInAppSymbols).\n\n2. **After exploring the icons collections, add one or more of the packages as dependencies to your project.**\n\n`npm i\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<IconDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired on mouseup, `SPACE` and `ENTER`.\n- on mouse click, the icon fires native `click` event\n- on `SPACE` and `ENTER`, the icon fires custom `click` event\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text alternative of the component.\nIf not provided a default text alternative will be set, if present.\n\n**Note:** Every icon should have a text alternative in order to\ncalculate its accessible name."
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "IconDesign | \"Contrast\" | \"Critical\" | \"Default\" | \"Information\" | \"Negative\" | \"Neutral\" | \"NonInteractive\" | \"Positive\"",
+            "value": [
+              {
+                "value": "\"Contrast\"",
+                "description": "Contrast design"
+              },
+              {
+                "value": "\"Critical\"",
+                "description": "Critical design"
+              },
+              {
+                "value": "\"Default\"",
+                "description": "Default design (brand design)"
+              },
+              {
+                "value": "\"Information\"",
+                "description": "info type"
+              },
+              {
+                "value": "\"Negative\"",
+                "description": "Negative design"
+              },
+              {
+                "value": "\"Neutral\"",
+                "description": "Neutral design"
+              },
+              {
+                "value": "\"NonInteractive\"",
+                "description": "Design that indicates an icon which isn't interactive"
+              },
+              {
+                "value": "\"Positive\"",
+                "description": "Positive design"
+              },
+              {
+                "value": "\"Contrast\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Neutral\""
+              },
+              {
+                "value": "\"NonInteractive\""
+              },
+              {
+                "value": "\"Positive\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component semantic design.\n\n**Note:** Available since [v1.9.2](https://github.com/UI5/webcomponents/releases/tag/v1.9.2) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "mode": {
+          "type": {
+            "name": "enum",
+            "raw": "IconMode | \"Image\" | \"Decorative\" | \"Interactive\"",
+            "value": [
+              {
+                "value": "\"Image\"",
+                "description": "Image mode (by default).\nConfigures the component to internally render role=\"img\"."
+              },
+              {
+                "value": "\"Decorative\"",
+                "description": "Decorative mode.\nConfigures the component to internally render role=\"presentation\" and aria-hidden=\"true\",\nmaking it purely decorative without semantic content or interactivity."
+              },
+              {
+                "value": "\"Interactive\"",
+                "description": "Interactive mode.\nConfigures the component to internally render role=\"button\".\nThis mode also supports focus and press handling to enhance interactivity."
+              },
+              {
+                "value": "\"Image\""
+              },
+              {
+                "value": "\"Decorative\""
+              },
+              {
+                "value": "\"Interactive\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the mode of the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Decorative\""
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the unique identifier (icon name) of the component.\n\nTo browse all available icons, see the\n[SAP Icons](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html),\n[SAP Fiori Tools](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html#/overview/SAP-icons-TNT) and\n[SAP Business Suite](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)\n\nExample:\n`name='add'`, `name='delete'`, `name='employee'`.\n\n**Note:** To use the SAP Fiori Tools icons,\nyou need to set the `tnt` prefix in front of the icon's name.\n\nExample:\n`name='tnt/antenna'`, `name='tnt/actor'`, `name='tnt/api'`.\n\n**Note:** To use the SAP Business Suite icons,\nyou need to set the `business-suite` prefix in front of the icon's name.\n\nExample:\n`name='business-suite/3d'`, `name='business-suite/1x2-grid-layout'`, `name='business-suite/4x4-grid-layout'`."
+        },
+        "showTooltip": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should have a tooltip.\n\n**Note:** The tooltip text should be provided via the `accessible-name` property.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<IconDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "root",
+          "description": "Used to style the outermost wrapper of the `ui5-icon`."
+        }
+      ]
+    },
+    "IllustratedMessage": {
+      "package": "@ui5/webcomponents-react",
+      "description": "An IllustratedMessage is a recommended combination of a solution-oriented message, an engaging\nillustration, and conversational tone to better communicate an empty or a success state than just show\na message alone.\n\nEach illustration has default internationalised title and subtitle texts. Also they can be managed with\n`titleText` and `subtitleText` properties.\n\nTo display the desired illustration, use the `name` property, where you can find the list of all available illustrations.\n\n**Note:** By default the “BeforeSearch” illustration is loaded. To use other illustrations, make sure you import them in addition, for example:\n\n`import \"@ui5/webcomponents-fiori/dist/illustrations/NoData.js\"`\n\n**Note:** Illustrations starting with the “Tnt” prefix are part of another illustration set. For example to use the “TntSuccess” illustration, add the following import::\n\n`import \"@ui5/webcomponents-fiori/dist/illustrations/tnt/Success.js\"`\n\n### Structure\nThe IllustratedMessage consists of the following elements, which are displayed below each other in the following order:\n\n- Illustration\n- Title\n- Subtitle\n- Actions\n\n### Usage\n`IllustratedMessage` is meant to be used inside container component, for example a `ui5-card`,\na `ui5-dialog` or a `Page`\n\n\n\n__Note:__ This is a UI5 Web Component! [IllustratedMessage UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/IllustratedMessage) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the component actions.\n\n**Note:** Not displayed when the `design` property is set to `Base`.\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "subtitle": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the subtitle of the component.\n\n**Note:** Using this slot, the default subtitle text of illustration and the value of `subtitleText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"subtitle\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "title": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the title of the component.\n\n**Note:** Using this slot, the default title text of illustration and the value of `title` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"title\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.7.0](https://github.com/UI5/webcomponents/releases/tag/v1.7.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement> & string`"
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.7.0](https://github.com/UI5/webcomponents/releases/tag/v1.7.0) of **@ui5/webcomponents-fiori**."
+        },
+        "decorative": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the illustration is decorative.\n\nWhen set to `true`, the attributes `role=\"presentation\"` and `aria-hidden=\"true\"` are applied to the SVG element.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "IllustrationMessageDesign | \"Auto\" | \"Base\" | \"Dot\" | \"Spot\" | \"Dialog\" | \"Scene\" | \"ExtraSmall\" | \"Small\" | \"Medium\" | \"Large\"",
+            "value": [
+              {
+                "value": "\"Auto\"",
+                "description": "Automatically decides the <code>Illustration</code> size (<code>Base</code>, <code>Dot</code>, <code>Spot</code>,\n<code>Dialog</code>, or <code>Scene</code>) depending on the <code>IllustratedMessage</code> container width.\n\n**Note:** `Auto` is the only option where the illustration size is changed according to\nthe available container width. If any other `IllustratedMessageSize` is chosen, it remains\nuntil changed by the app developer."
+              },
+              {
+                "value": "\"Base\"",
+                "description": "Base `Illustration` size (XS breakpoint). Suitable for cards (two columns).\n\n**Note:** When `Base` is in use, no illustration is displayed."
+              },
+              {
+                "value": "\"Dot\"",
+                "description": "Dot <code>Illustration</code> size (XS breakpoint). Suitable for table rows."
+              },
+              {
+                "value": "\"Spot\"",
+                "description": "Spot <code>Illustration</code> size (S breakpoint). Suitable for cards (four columns)."
+              },
+              {
+                "value": "\"Dialog\"",
+                "description": "Dialog `Illustration` size (M breakpoint). Suitable for dialogs."
+              },
+              {
+                "value": "\"Scene\"",
+                "description": "Scene `Illustration` size (L breakpoint). Suitable for a `Page` or a table."
+              },
+              {
+                "value": "\"ExtraSmall\"",
+                "description": "ExtraSmall <code>Illustration</code> size (XS breakpoint). Suitable for table rows."
+              },
+              {
+                "value": "\"Small\"",
+                "description": "Small <code>Illustration</code> size (S breakpoint). Suitable for cards (four columns)."
+              },
+              {
+                "value": "\"Medium\"",
+                "description": "Medium `Illustration` size (M breakpoint). Suitable for dialogs."
+              },
+              {
+                "value": "\"Large\"",
+                "description": "Large `Illustration` size (L breakpoint). Suitable for a `Page` or a table."
+              },
+              {
+                "value": "\"Auto\""
+              },
+              {
+                "value": "\"Base\""
+              },
+              {
+                "value": "\"Dot\""
+              },
+              {
+                "value": "\"Spot\""
+              },
+              {
+                "value": "\"Dialog\""
+              },
+              {
+                "value": "\"Scene\""
+              },
+              {
+                "value": "\"ExtraSmall\""
+              },
+              {
+                "value": "\"Small\""
+              },
+              {
+                "value": "\"Medium\""
+              },
+              {
+                "value": "\"Large\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines which illustration breakpoint variant is used.\n\nAs `IllustratedMessage` adapts itself around the `Illustration`, the other\nelements of the component are displayed differently on the different breakpoints/illustration designs.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"Auto\""
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the illustration name that will be displayed in the component.\n\nExample:\n\n`name='BeforeSearch'`, `name='UnableToUpload'`, etc..\n\n**Note:** To use the TNT illustrations,\nyou need to set the `tnt` or `Tnt` prefix in front of the icon's name.\n\nExample:\n\n`name='tnt/Avatar'` or `name='TntAvatar'`.\n\n**Note:** By default the `BeforeSearch` illustration is loaded.\nWhen using an illustration type, other than the default, it should be loaded in addition:\n\n`import \"@ui5/webcomponents-fiori/dist/illustrations/NoData.js\";`\n\nFor TNT illustrations:\n\n`import \"@ui5/webcomponents-fiori/dist/illustrations/tnt/SessionExpired.js\";`",
+          "defaultValue": {
+            "value": "\"BeforeSearch\""
+          }
+        },
+        "subtitleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the subtitle of the component.\n\n**Note:** Using this property, the default subtitle text of illustration will be overwritten.\n\n**Note:** Using `subtitle` slot, the default of this property will be overwritten."
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the title of the component.\n\n**Note:** Using this property, the default title text of illustration will be overwritten."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<IllustratedMessageDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "subtitle",
+          "description": "Used to style the subtitle wrapper of the `ui5-illustrated-message`"
+        }
+      ]
+    },
+    "Input": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Input` component allows the user to enter and edit text or numeric values in one line.\n\nAdditionally, you can provide `suggestionItems`,\nthat are displayed in a popover right under the input.\n\nThe text field can be editable or read-only (`readonly` property),\nand it can be enabled or disabled (`disabled` property).\nTo visualize semantic states, such as \"Negative\" or \"Critical\", the `valueState` property is provided.\nWhen the user makes changes to the text, the change event is fired,\nwhich enables you to react on any text change.\n\n### Keyboard Handling\nThe `Input` provides the following keyboard shortcuts:\n\n- [Escape] - Closes the suggestion list, if open. If closed or not enabled, cancels changes and reverts to the value which the Input field had when it got the focus.\n- [Enter] or [Return] - If suggestion list is open takes over the current matching item and closes it. If value state or group header is focused, does nothing.\n- [Down] - Focuses the next matching item in the suggestion list. Selection-change event is fired.\n- [Up] - Focuses the previous matching item in the suggestion list. Selection-change event is fired.\n- [Home] - If focus is in the text input, moves caret before the first character. If focus is in the list, highlights the first item and updates the input accordingly.\n- [End] - If focus is in the text input, moves caret after the last character. If focus is in the list, highlights the last item and updates the input accordingly.\n- [Page Up] - If focus is in the list, moves highlight up by page size (10 items by default). If focus is in the input, does nothing.\n- [Page Down] - If focus is in the list, moves highlight down by page size (10 items by default). If focus is in the input, does nothing.\n- [Ctrl]+[Alt]+[F8] or [Command]+[Option]+[F8] - Focuses the first link in the value state message, if available. Pressing [Tab] moves the focus to the next link in the value state message, or closes the value state message if there are no more links.\n\n\n\n__Note:__ This is a UI5 Web Component! [Input UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Input) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the suggestion items.\n\n**Note:** The suggestions would be displayed only if the `showSuggestions`\nproperty is set to `true`.\n\n**Note:** The `<SuggestionItem>`, `<SuggestionItemGroup>` and `SuggestionItemCustom` are recommended to be used as suggestion items.\n\n__Supported Node Type/s:__ `Array<IInputSuggestionItem>`"
+        },
+        "icon": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed in the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
+        },
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n**Note:** If the component has `suggestionItems`,\nthe `valueStateMessage` would be displayed as part of the same popover, if used on desktop, or dialog - on phone.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the suggestions picker is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the component changes at each keystroke,\nand when a suggestion item has been selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the suggestions picker is open.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSelect": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when some text has been selected.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, InputSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user navigates to a suggestion item via the ARROW keys,\nas a preview, before the final selection.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The previewed suggestion item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the input."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "filter": {
+          "type": {
+            "name": "enum",
+            "raw": "InputSuggestionsFilter | \"StartsWithPerTerm\" | \"StartsWith\" | \"Contains\" | \"None\"",
+            "value": [
+              {
+                "value": "\"StartsWithPerTerm\"",
+                "description": "Defines filtering by first symbol of each word of item's text."
+              },
+              {
+                "value": "\"StartsWith\"",
+                "description": "Defines filtering by starting symbol of item's text."
+              },
+              {
+                "value": "\"Contains\"",
+                "description": "Defines contains filtering."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Removes any filtering applied while typing"
+              },
+              {
+                "value": "\"StartsWithPerTerm\""
+              },
+              {
+                "value": "\"StartsWith\""
+              },
+              {
+                "value": "\"Contains\""
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the filter type of the component.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "maxlength": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Sets the maximum number of characters available in the input field.\n\n**Note:** This property is not compatible with the ui5-input type InputType.Number. If the ui5-input type is set to Number, the maxlength value is ignored."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
+        },
+        "noTypeahead": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the value will be autcompleted to match an item\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the suggestions picker is open.\nThe picker will not open if the `showSuggestions` property is set to `false`, the input is disabled or the input is readonly.\nThe picker will close automatically and `close` event will be fired if the input is not in the viewport.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showClearIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showSuggestions": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should show suggestions, if such are present.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "InputType | \"Text\" | \"Email\" | \"Number\" | \"Password\" | \"Tel\" | \"URL\" | \"Search\"",
+            "value": [
+              {
+                "value": "\"Text\"",
+                "description": "Defines a one-line text input field:"
+              },
+              {
+                "value": "\"Email\"",
+                "description": "Used for input fields that must contain an e-mail address."
+              },
+              {
+                "value": "\"Number\"",
+                "description": "Defines a numeric input field."
+              },
+              {
+                "value": "\"Password\"",
+                "description": "Defines a password field."
+              },
+              {
+                "value": "\"Tel\"",
+                "description": "Used for input fields that should contain a telephone number."
+              },
+              {
+                "value": "\"URL\"",
+                "description": "Used for input fields that should contain a URL address."
+              },
+              {
+                "value": "\"Search\"",
+                "description": "Used for input fields that should contain a search term."
+              },
+              {
+                "value": "\"Text\""
+              },
+              {
+                "value": "\"Email\""
+              },
+              {
+                "value": "\"Number\""
+              },
+              {
+                "value": "\"Password\""
+              },
+              {
+                "value": "\"Tel\""
+              },
+              {
+                "value": "\"URL\""
+              },
+              {
+                "value": "\"Search\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the HTML type of the component.\n\n**Notes:**\n\n- The particular effect of this property differs depending on the browser\nand the current language settings, especially for type `Number`.\n- The property is mostly intended to be used with touch devices\nthat use different soft keyboard layouts depending on the given input type.",
+          "defaultValue": {
+            "value": "\"Text\""
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<InputDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "clear-icon",
+          "description": "Used to style the clear icon, which can be pressed to clear user input text"
+        },
+        {
+          "name": "input",
+          "description": "Used to style the native input element"
+        },
+        {
+          "name": "root",
+          "description": "Used to style the root DOM element of the Input component"
+        }
+      ]
+    },
+    "Label": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Label` is a component used to represent a label for elements like input, textarea, select.\nThe `for` property of the `Label` must be the same as the id attribute of the related input element.\nScreen readers read out the label, when the user focuses the labelled control.\n\nThe `Label` appearance can be influenced by properties,\nsuch as `required` and `wrappingType`.\nThe appearance of the Label can be configured in a limited way by using the design property.\nFor a broader choice of designs, you can use custom styles.\n\n\n\n__Note:__ This is a UI5 Web Component! [Label UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Label) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "for": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the labeled input by providing its ID.\n\n**Note:** Can be used with both `Input` and native input."
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether an asterisk character is added to the component text.\n\n**Note:** Usually indicates that user input (bound with the `for` property) is required.\nIn that case the `required` property of\nthe corresponding input should also be set.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showColon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether colon is added to the component text.\n\n**Note:** Usually used in forms.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "WrappingType | \"None\" | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines how the text of a component will be displayed when there is not enough space.\n\n**Note:** for option \"Normal\" the text will wrap and the words will not be broken based on hyphenation.",
+          "defaultValue": {
+            "value": "\"Normal\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<LabelDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Link": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Link` is a hyperlink component that is used to navigate to other\napps and web pages, or to trigger actions.\nIt is a clickable text element, visualized in such a way that it stands out\nfrom the standard text.\nOn hover, it changes its style to an underlined text to provide additional feedback to the user.\n\n### Usage\n\nYou can set the `Link` to be enabled or disabled.\n\nTo create a visual hierarchy in large lists of links, you can set the less important links as\n`Subtle` or the more important ones as `Emphasized`,\nby using the `design` property.\n\nIf the `href` property is set, the link behaves as the HTML\nanchor tag (`<a></a>`) and opens the specified URL in the given target frame (`target` property).\nTo specify where the linked content is opened, you can use the `target` property.\n\n### Responsive behavior\n\nIf there is not enough space, the text of the `Link` becomes truncated.\nIf the `wrappingType` property is set to `\"Normal\"`, the text is displayed\non several lines instead of being truncated.\n\n\n\n__Note:__ This is a UI5 Web Component! [Link UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Link) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<LinkDomRef, LinkClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is triggered either with a mouse/tap\nor by using the Enter key.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "altKey",
+                "type": "boolean",
+                "description": "Returns whether the \"ALT\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "ctrlKey",
+                "type": "boolean",
+                "description": "Returns whether the \"CTRL\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "metaKey",
+                "type": "boolean",
+                "description": "Returns whether the \"META\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "shiftKey",
+                "type": "boolean",
+                "description": "Returns whether the \"SHIFT\" key was pressed when the event was triggered."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "LinkAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls, is currently expanded or collapsed.\nAccepts the following string values: `true` or `false`.\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the input"
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "LinkAccessibleRole | \"Link\" | \"Button\"",
+            "value": [
+              {
+                "value": "\"Link\"",
+                "description": "Represents Default (link) ARIA role."
+              },
+              {
+                "value": "\"Button\"",
+                "description": "Represents the ARIA role \"button\"."
+              },
+              {
+                "value": "\"Link\""
+              },
+              {
+                "value": "\"Button\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the ARIA role of the component.\n\n**Note:** Use the <code>LinkAccessibleRole.Button</code> role in cases when navigation is not expected to occur and the href property is not defined.\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Link\""
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "LinkDesign | \"Default\" | \"Subtle\" | \"Emphasized\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "default type (no special styling)"
+              },
+              {
+                "value": "\"Subtle\"",
+                "description": "subtle type (appears as regular text, rather than a link)"
+              },
+              {
+                "value": "\"Emphasized\"",
+                "description": "emphasized type"
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Subtle\""
+              },
+              {
+                "value": "\"Emphasized\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component design.\n\n**Note:** Avaialble options are `Default`, `Subtle`, and `Emphasized`.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\n\n**Note:** When disabled, the click event cannot be triggered by the user.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "endIcon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon, displayed as graphical element within the component after the link's text.\nThe SAP-icons font provides numerous options.\n\n**Note:** Usage of icon-only link is not supported, the link must always have a text.\n\n**Note:** We recommend using аn icon in the beginning or the end only, and with text.\n\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
+        },
+        "href": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the component href.\n\n**Note:** Standard hyperlink behavior is supported."
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon, displayed as graphical element within the component before the link's text.\nThe SAP-icons font provides numerous options.\n\n**Note:** Usage of icon-only link is not supported, the link must always have a text.\n\n**Note:** We recommend using аn icon in the beginning or the end only, and with text.\n\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
+        },
+        "interactiveAreaSize": {
+          "type": {
+            "name": "enum",
+            "raw": "InteractiveAreaSize | \"Normal\" | \"Large\"",
+            "value": [
+              {
+                "value": "\"Normal\"",
+                "description": "The default target area size (the area taken by the component itself without any extra invisible touch area)."
+              },
+              {
+                "value": "\"Large\"",
+                "description": "Enlarged target area size (up to 24px in height) provides users with an enhanced dedicated space to interact with the component."
+              },
+              {
+                "value": "\"Normal\""
+              },
+              {
+                "value": "\"Large\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the target area size of the link:\n- **InteractiveAreaSize.Normal**: The default target area size.\n- **InteractiveAreaSize.Large**: The target area size is enlarged to 24px in height.\n\n**Note:**The property is designed to make links easier to activate and helps meet the WCAG 2.2 Target Size requirement. It is applicable only for the SAP Horizon themes.\n**Note:**To improve <code>ui5-link</code>'s reliability and usability, it is recommended to use the <code>InteractiveAreaSize.Large</code> value in scenarios where the <code>ui5-link</code> component is placed inside another interactive component, such as a list item or a table cell.\nSetting the <code>interactiveAreaSize</code> property to <code>InteractiveAreaSize.Large</code> increases the <code>ui5-link</code>'s invisible touch area. As a result, the user's intended one-time selection command is more likely to activate the desired <code>ui5-link</code>, with minimal chance of unintentionally activating the underlying component.\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Normal\""
+          }
+        },
+        "target": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the component target.\n\n**Notes:**\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `_search`\n\n**This property must only be used when the `href` property is set.**"
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Normal\" | WrappingType | \"None\"",
+            "value": [
+              {
+                "value": "\"Normal\""
+              },
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines how the text of a component will be displayed when there is not enough space.\n\n**Note:** By default the text will wrap. If \"None\" is set - the text will truncate.",
+          "defaultValue": {
+            "value": "\"Normal\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<LinkDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "endIcon",
+          "description": "Used to style the provided endIcon within the link"
+        },
+        {
+          "name": "icon",
+          "description": "Used to style the provided icon within the link"
+        }
+      ]
+    },
+    "List": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `List` component allows displaying a list of items, advanced keyboard\nhandling support for navigating between items, and predefined modes to improve the development efficiency.\n\nThe `List` is a container for the available list items:\n\n- `ListItemStandard`\n- `ListItemCustom`\n- `ListItemGroup`\n\nTo benefit from the built-in selection mechanism, you can use the available\nselection modes, such as\n`Single`, `Multiple` and `Delete`.\n\nAdditionally, the `List` provides header, footer, and customization for the list item separators.\n\n### Keyboard Handling\n\n#### Basic Navigation\nThe `List` provides advanced keyboard handling.\nWhen a list is focused the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Up] or [Down] - Navigates up and down the items\n- [Home] - Navigates to first item\n- [End] - Navigates to the last item\n\nThe user can use the following keyboard shortcuts to perform actions (such as select, delete),\nwhen the `selectionMode` property is in use:\n\n- [Space] - Select an item (if `type` is 'Active') when `selectionMode` is selection\n- [Delete] - Delete an item if `selectionMode` property is `Delete`\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n`import \"@ui5/webcomponents/dist/ListItemStandard.js\";` (for `ListItemStandard`)\n\n`import \"@ui5/webcomponents/dist/ListItemCustom.js\";` (for `ListItemCustom`)\n\n`import \"@ui5/webcomponents/dist/ListItemGroup.js\";` (for `ListItemGroup`)\n\n__Note:__ This is a UI5 Web Component! [List UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/List) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the component.\n\n**Note:** Use `ListItemStandard`, `ListItemCustom`, and `ListItemGroup` for the intended design.\n\n__Supported Node Type/s:__ `Array<ListItemBase | ListItemGroup>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the component header.\n\n**Note:** When `header` is set, the\n`headerText` property is ignored.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onItemClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListDomRef, ListItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when an item is activated, unless the item's `type` property\nis set to `Inactive`.\n\n**Note**: This event is not triggered by interactions with selection components such as the checkboxes and radio buttons,\nassociated with non-default `selectionMode` values, or if any other **interactive** component\n(such as a button or input) within the list item is directly clicked.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The clicked item."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onItemClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListDomRef, ListItemCloseEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `Close` button of any item is clicked\n\n**Note:** This event is only applicable to list items that can be closed (such as notification list items),\nnot to be confused with `item-delete`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "the item about to be closed."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onItemDelete": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListDomRef, ListItemDeleteEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the Delete button of any item is pressed.\n\n**Note:** A Delete button is displayed on each item,\nwhen the component `selectionMode` property is set to `Delete`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "the deleted item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onItemToggle": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListDomRef, ListItemToggleEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `Toggle` button of any item is clicked.\n\n**Note:** This event is only applicable to list items that can be toggled (such as notification group list items).\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "the toggled item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onLoadMore": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user scrolls to the bottom of the list.\n\n**Note:** The event is fired when the `growing='Scroll'` property is enabled.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMove": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListDomRef, MoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMoveOver": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListDomRef, MoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListDomRef, ListSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when selection is changed by user interaction\nin `Single`, `SingleStart`, `SingleEnd` and `Multiple` selection modes.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "previouslySelectedItems",
+                "type": "Array<ListItemBase>",
+                "description": "An array of the previously selected items."
+              },
+              {
+                "name": "selectedItems",
+                "type": "Array<ListItemBase>",
+                "description": "An array of the selected items."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ListAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines additional accessibility attributes on different areas of the component.\n\nThe accessibilityAttributes object has the following field:\n\n - **growingButton**: `growingButton.name`, `growingButton.description`.\n\n The accessibility attributes support the following values:\n\n- **name**: Defines the accessible ARIA name of the growing button.\nAccepts any string.\n\n- **description**: Defines the accessible ARIA description of the growing button.\nAccepts any string.\n\n **Note:** The `accessibilityAttributes` property is in an experimental state and is a subject to change.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that describe the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that label the component."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "ListAccessibleRole | \"List\" | \"Menu\" | \"Tree\" | \"ListBox\"",
+            "value": [
+              {
+                "value": "\"List\"",
+                "description": "Represents the ARIA role \"list\". (by default)"
+              },
+              {
+                "value": "\"Menu\"",
+                "description": "Represents the ARIA role \"menu\"."
+              },
+              {
+                "value": "\"Tree\"",
+                "description": "Represents the ARIA role \"tree\"."
+              },
+              {
+                "value": "\"ListBox\"",
+                "description": "Represents the ARIA role \"listbox\"."
+              },
+              {
+                "value": "\"List\""
+              },
+              {
+                "value": "\"Menu\""
+              },
+              {
+                "value": "\"Tree\""
+              },
+              {
+                "value": "\"ListBox\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the accessible role of the component.",
+          "defaultValue": {
+            "value": "\"List\""
+          }
+        },
+        "footerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the footer text."
+        },
+        "growing": {
+          "type": {
+            "name": "enum",
+            "raw": "ListGrowingMode | \"Button\" | \"Scroll\" | \"None\"",
+            "value": [
+              {
+                "value": "\"Button\"",
+                "description": "Component's \"load-more\" is fired upon pressing a \"More\" button.\nat the bottom."
+              },
+              {
+                "value": "\"Scroll\"",
+                "description": "Component's \"load-more\" is fired upon scroll."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Component's growing is not enabled."
+              },
+              {
+                "value": "\"Button\""
+              },
+              {
+                "value": "\"Scroll\""
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines whether the component will have growing capability either by pressing a `More` button,\nor via user scroll. In both cases `load-more` event is fired.\n\n**Restrictions:** `growing=\"Scroll\"` is not supported for Internet Explorer,\non IE the component will fallback to `growing=\"Button\"`.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "growingButtonText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text that will be displayed inside the growing button.\n\n**Note:** If not specified a built-in text will be displayed.\n\n**Note:** This property takes effect if the `growing` property is set to the `Button`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**."
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the component header text.\n\n**Note:** If `header` is set this property is ignored."
+        },
+        "indent": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is indented.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the component would display a loading indicator over the list.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the loading indicator will show up for this component.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "noDataText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text that is displayed when the component contains no items."
+        },
+        "selectionMode": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | ListSelectionMode | \"Single\" | \"SingleStart\" | \"SingleEnd\" | \"SingleAuto\" | \"Multiple\" | \"Delete\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\"",
+                "description": "Default mode (no selection)."
+              },
+              {
+                "value": "\"Single\"",
+                "description": "Right-positioned single selection mode (only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleStart\"",
+                "description": "Left-positioned single selection mode (only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleEnd\"",
+                "description": "Selected item is highlighted but no selection element is visible\n(only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleAuto\"",
+                "description": "Selected item is highlighted and selection is changed upon arrow navigation\n(only one list item can be selected - this is always the focused item)."
+              },
+              {
+                "value": "\"Multiple\"",
+                "description": "Multi selection mode (more than one list item can be selected)."
+              },
+              {
+                "value": "\"Delete\"",
+                "description": "Delete mode (only one list item can be deleted via provided delete button)"
+              },
+              {
+                "value": "\"Single\""
+              },
+              {
+                "value": "\"SingleStart\""
+              },
+              {
+                "value": "\"SingleEnd\""
+              },
+              {
+                "value": "\"SingleAuto\""
+              },
+              {
+                "value": "\"Multiple\""
+              },
+              {
+                "value": "\"Delete\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the selection mode of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "separators": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | ListSeparator | \"All\" | \"Inner\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"All\"",
+                "description": "Separators between the items including the last and the first one."
+              },
+              {
+                "value": "\"Inner\"",
+                "description": "Separators between the items.\nNote: This enumeration depends on the theme."
+              },
+              {
+                "value": "\"None\"",
+                "description": "No item separators."
+              },
+              {
+                "value": "\"All\""
+              },
+              {
+                "value": "\"Inner\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the item separator style that is used.",
+          "defaultValue": {
+            "value": "\"All\""
+          }
+        },
+        "stickyHeader": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the List header is sticky or not.\nIf stickyHeader is set to true, then whenever you scroll the content or\nthe application, the header of the list will be always visible.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ListDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "growing-button",
+          "description": "Used to style the button, that is used for growing of the component"
+        },
+        {
+          "name": "growing-button-inner",
+          "description": "Used to style the button inner element"
+        }
+      ]
+    },
+    "ListItemCustom": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A component to be used as custom list item within the `List`\nthe same way as the standard `ListItemStandard`.\n\nThe component accepts arbitrary HTML content to allow full customization.\n\n__Note:__ This is a UI5 Web Component! [ListItemCustom UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ListItemCustom) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "deleteButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `Button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "onDetailClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListItemCustomDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ListItemAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text alternative of the component.\n\n**Note**: If not provided a default text alternative will be set, if present."
+        },
+        "highlight": {
+          "type": {
+            "name": "enum",
+            "raw": "Highlight | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "movable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the item is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "navigated": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
+            "value": [
+              {
+                "value": "\"Inactive\"",
+                "description": "Indicates the list item does not have any active feedback when item is pressed."
+              },
+              {
+                "value": "\"Active\"",
+                "description": "Indicates that the item is clickable via active feedback when item is pressed."
+              },
+              {
+                "value": "\"Detail\"",
+                "description": "Enables detail button of the list item that fires detail-click event."
+              },
+              {
+                "value": "\"Navigation\"",
+                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
+              },
+              {
+                "value": "\"Inactive\""
+              },
+              {
+                "value": "\"Active\""
+              },
+              {
+                "value": "\"Detail\""
+              },
+              {
+                "value": "\"Navigation\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
+          "defaultValue": {
+            "value": "\"Active\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ListItemCustomDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "checkbox",
+          "description": "Used to style the checkbox rendered when the list item is in multiple selection mode"
+        },
+        {
+          "name": "content",
+          "description": "Used to style the content area of the list item"
+        },
+        {
+          "name": "delete-button",
+          "description": "Used to style the button rendered when the list item is in delete mode"
+        },
+        {
+          "name": "detail-button",
+          "description": "Used to style the button rendered when the list item is of type detail"
+        },
+        {
+          "name": "native-li",
+          "description": "Used to style the main li tag of the list item"
+        },
+        {
+          "name": "radio",
+          "description": "Used to style the radio button rendered when the list item is in single selection mode"
+        }
+      ]
+    },
+    "ListItemGroup": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ListItemGroup` is a special list item, used only to create groups of list items.\n\nThis is the item to use inside a `List`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ListItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ListItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the <code>ui5-li-group</code>.\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
+        },
+        "onMove": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMoveOver": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "headerAccessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the header."
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text of the <code>ui5-li-group</code>."
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "WrappingType | \"None\" | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ExpandableText` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ListItemGroupDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "header",
+          "description": "Used to style the header item of the group"
+        },
+        {
+          "name": "title",
+          "description": "Used to style the title of the group header"
+        }
+      ]
+    },
+    "ListItemStandard": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ListItemStandard` represents the simplest type of item for a `List`.\n\nThis is a list item,\nproviding the most common use cases such as `text`,\n`image` and `icon`.\n\n__Note:__ This is a UI5 Web Component! [ListItemStandard UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ListItemStandard) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the custom formatted text of the component.\n\n**Note:** For optimal text wrapping and a consistent layout, it is strongly recommended to use the `text` property.\n\nUse the `default` slot only when custom formatting with HTML elements (e.g., `<b>`, `<i>`) is required.\nBe aware that wrapping (via `wrappingType=\"Normal\"`) may not function correctly with custom HTML content in the `default` slot.\n\nIf both `text` and `default` slot are used, the `text` property takes precedence.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "deleteButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `Button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "image": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "**Note:** While the slot allows option for setting custom avatar, to match the\ndesign guidelines, please use the `Avatar` with it's default size - S.\n\n**Note:** If bigger `Avatar` needs to be used, then the size of the\n`ListItemStandard` should be customized in order to fit.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"image\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onDetailClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ListItemStandardDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ListItemAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text alternative of the component.\nNote: If not provided a default text alternative will be set, if present."
+        },
+        "additionalText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `additionalText`, displayed in the end of the list item."
+        },
+        "additionalTextState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the state of the `additionalText`.\n\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "description": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the description displayed right under the item text, if such is present."
+        },
+        "highlight": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\" | Highlight",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `icon` source URI.\n\n**Note:**\nSAP-icons font provides numerous built-in icons. To find all the available icons, see the\n[Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "iconEnd": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the `icon` should be displayed in the beginning of the list item or in the end.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "movable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the item is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "navigated": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**."
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
+            "value": [
+              {
+                "value": "\"Inactive\"",
+                "description": "Indicates the list item does not have any active feedback when item is pressed."
+              },
+              {
+                "value": "\"Active\"",
+                "description": "Indicates that the item is clickable via active feedback when item is pressed."
+              },
+              {
+                "value": "\"Detail\"",
+                "description": "Enables detail button of the list item that fires detail-click event."
+              },
+              {
+                "value": "\"Navigation\"",
+                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
+              },
+              {
+                "value": "\"Inactive\""
+              },
+              {
+                "value": "\"Active\""
+              },
+              {
+                "value": "\"Detail\""
+              },
+              {
+                "value": "\"Navigation\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
+          "defaultValue": {
+            "value": "\"Active\""
+          }
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | WrappingType | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ExpandableText` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ListItemStandardDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "additional-text",
+          "description": "Used to style the additionalText of the list item"
+        },
+        {
+          "name": "checkbox",
+          "description": "Used to style the checkbox rendered when the list item is in multiple selection mode"
+        },
+        {
+          "name": "content",
+          "description": "Used to style the content area of the list item"
+        },
+        {
+          "name": "delete-button",
+          "description": "Used to style the button rendered when the list item is in delete mode"
+        },
+        {
+          "name": "description",
+          "description": "Used to style the description of the list item"
+        },
+        {
+          "name": "detail-button",
+          "description": "Used to style the button rendered when the list item is of type detail"
+        },
+        {
+          "name": "icon",
+          "description": "Used to style the icon of the list item"
+        },
+        {
+          "name": "native-li",
+          "description": "Used to style the main li tag of the list item"
+        },
+        {
+          "name": "radio",
+          "description": "Used to style the radio button rendered when the list item is in single selection mode"
+        },
+        {
+          "name": "title",
+          "description": "Used to style the title of the list item"
+        }
+      ]
+    },
+    "MediaGallery": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `MediaGallery` component allows the user to browse through multimedia items. Currently,\nthe supported items are images and videos. The items should be defined using the `MediaGalleryItem`\ncomponent.\n\nThe items are initially displayed as thumbnails. When the user selects a thumbnail, the corresponding item\nis displayed in larger size.\n\nThe component is responsive by default and adjusts the position of the menu with respect to viewport size,\nbut the application is able to further customize the layout via the provided API.\n\n### Keyboard Handling\nThe `MediaGallery` provides advanced keyboard handling.\n\nWhen the thumbnails menu is focused the following keyboard\nshortcuts allow the user to navigate through the thumbnail items:\n\n- [Up] or [Down] - Navigates up and down the items\n- [Home] - Navigates to first item\n- [End] - Navigates to the last item\n- [Space], [Enter] - Selects an item\n\n\n\n`import \"@ui5/webcomponents-fiori/dist/MediaGalleryItem.js\";`\n\n__Note:__ This is a UI5 Web Component! [MediaGallery UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/MediaGallery) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the component items.\n\n**Note:** Only one selected item is allowed.\n\n**Note:** Use the `MediaGalleryItem` component to define the desired items.\n\n__Supported Node Type/s:__ `Array<IMediaGalleryItem>`"
+        },
+        "onDisplayAreaClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MediaGalleryDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the display area is clicked.\nThe display area is the central area that contains\nthe enlarged content of the currently selected item.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onOverflowClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MediaGalleryDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the thumbnails overflow button is clicked.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MediaGalleryDomRef, MediaGallerySelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when selection is changed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "the selected item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "interactiveDisplayArea": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "If enabled, a `display-area-click` event is fired\nwhen the user clicks or taps on the display area.\n\nThe display area is the central area that contains\nthe enlarged content of the currently selected item.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "layout": {
+          "type": {
+            "name": "enum",
+            "raw": "MediaGalleryLayout | \"Auto\" | \"Vertical\" | \"Horizontal\"",
+            "value": [
+              {
+                "value": "\"Auto\"",
+                "description": "The layout is determined automatically."
+              },
+              {
+                "value": "\"Vertical\"",
+                "description": "Displays the layout as a vertical split between the thumbnails list and the selected image."
+              },
+              {
+                "value": "\"Horizontal\"",
+                "description": "Displays the layout as a horizontal split between the thumbnails list and the selected image."
+              },
+              {
+                "value": "\"Auto\""
+              },
+              {
+                "value": "\"Vertical\""
+              },
+              {
+                "value": "\"Horizontal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the layout of the component.",
+          "defaultValue": {
+            "value": "\"Auto\""
+          }
+        },
+        "menuHorizontalAlign": {
+          "type": {
+            "name": "enum",
+            "raw": "MediaGalleryMenuHorizontalAlign | \"Left\" | \"Right\"",
+            "value": [
+              {
+                "value": "\"Left\"",
+                "description": "Displays the menu on the left side of the target."
+              },
+              {
+                "value": "\"Right\"",
+                "description": "Displays the menu on the right side of the target."
+              },
+              {
+                "value": "\"Left\""
+              },
+              {
+                "value": "\"Right\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the horizontal alignment of the thumbnails menu\nvs. the central display area.",
+          "defaultValue": {
+            "value": "\"Left\""
+          }
+        },
+        "menuVerticalAlign": {
+          "type": {
+            "name": "enum",
+            "raw": "MediaGalleryMenuVerticalAlign | \"Top\" | \"Bottom\"",
+            "value": [
+              {
+                "value": "\"Top\"",
+                "description": "Displays the menu at the top of the reference control."
+              },
+              {
+                "value": "\"Bottom\"",
+                "description": "Displays the menu at the bottom of the reference control."
+              },
+              {
+                "value": "\"Top\""
+              },
+              {
+                "value": "\"Bottom\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the vertical alignment of the thumbnails menu\nvs. the central display area.",
+          "defaultValue": {
+            "value": "\"Bottom\""
+          }
+        },
+        "showAllThumbnails": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "If set to `true`, all thumbnails are rendered in a scrollable container.\nIf `false`, only up to five thumbnails are rendered, followed by\nan overflow button that shows the count of the remaining thumbnails.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<MediaGalleryDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "MediaGalleryItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `MediaGalleryItem` web component represents the items displayed in the\n`MediaGallery` web component.\n\n**Note:** `MediaGalleryItem` is not supported when used outside of `MediaGallery`.\n\n### Keyboard Handling\nThe `MediaGallery` provides advanced keyboard handling.\nWhen focused, the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Space] / [Enter] or [Return] - Trigger `ui5-click` event\n\n)\n\n__Note:__ This is a UI5 Web Component! [MediaGalleryItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/MediaGalleryItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "thumbnail": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content of the thumbnail.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"thumbnail\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in disabled state.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "layout": {
+          "type": {
+            "name": "enum",
+            "raw": "MediaGalleryItemLayout | \"Square\" | \"Wide\"",
+            "value": [
+              {
+                "value": "\"Square\"",
+                "description": "Recommended to use when the item contains an image.\n\nWhen a thumbnail is selected, it makes the corresponding enlarged content appear in a square display area."
+              },
+              {
+                "value": "\"Wide\"",
+                "description": "Recommended to use when the item contains video content.\n\nWhen a thumbnail is selected, it makes the corresponding enlarged content appear in a wide display area\n(stretched to fill all of the available width) for optimal user experiance."
+              },
+              {
+                "value": "\"Square\""
+              },
+              {
+                "value": "\"Wide\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the layout of the item container.",
+          "defaultValue": {
+            "value": "\"Square\""
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<MediaGalleryItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Menu": {
+      "package": "@ui5/webcomponents-react",
+      "description": "`Menu` component represents a hierarchical menu structure.\n\n### Structure\n\nThe `Menu` can hold two types of entities:\n\n- `MenuItem` components\n- `MenuSeparator` - used to separate menu items with a line\n\nAn arbitrary hierarchy structure can be represented by recursively nesting menu items.\n\n### Keyboard Handling\n\nThe `Menu` provides advanced keyboard handling.\nThe user can use the following keyboard shortcuts in order to navigate trough the tree:\n\n- `Arrow Up` / `Arrow Down` - Navigates up and down the menu items that are currently visible.\n- `Arrow Right`, `Space` or `Enter` - Opens a sub-menu if there are menu items nested\nin the currently clicked menu item.\n- `Arrow Left` or `Escape` - Closes the currently opened sub-menu.\n\nwhen there is `endContent` :\n- `Arrow Left` or `ArrowRight` - Navigate between the menu item actions and the menu item itself\n- `Arrow Up` / `Arrow Down` - Navigates up and down the currently visible menu items\n\n**Note:** If the text direction is set to Right-to-left (RTL), `Arrow Right` and `Arrow Left` functionality is swapped.\n\nApplication developers are responsible for ensuring that interactive elements placed in the `endContent` slot\nhave the correct accessibility behaviour, including their enabled or disabled states.\nThe menu does not manage these aspects when the menu item state changes.\n\n\n\n__Note:__ This is a UI5 Web Component! [Menu UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Menu) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of this component.\n\n**Note:** Use `MenuItem` and `MenuSeparator` for their intended design.\n\n__Supported Node Type/s:__ `Array<IMenuItem>`"
+        },
+        "onBeforeClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MenuDomRef, MenuBeforeCloseEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the menu is closed. This event can be cancelled, which will prevent the menu from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "escPressed",
+                "type": "boolean",
+                "description": "Indicates that `ESC` key has triggered the event."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onBeforeOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MenuDomRef, MenuBeforeOpenEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the menu is opened. This event can be cancelled, which will prevent the menu from opening.\n\n**Note:** Since 1.14.0 the event is also fired before a sub-menu opens.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The `ui5-menu-item` that triggers opening of the sub-menu or undefined when fired upon root menu opening."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MenuDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the menu is closed.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onItemClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MenuDomRef, MenuItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when an item is being clicked.\n\n**Note:** Since 1.17.0 the event is preventable, allowing the menu to remain open after an item is pressed.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The currently clicked menu item."
+              },
+              {
+                "name": "text",
+                "type": "string",
+                "description": "The text of the currently clicked menu item."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MenuDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the menu is opened.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text of the menu (displayed on mobile)."
+        },
+        "horizontalAlign": {
+          "type": {
+            "name": "enum",
+            "raw": "PopoverHorizontalAlign | \"Center\" | \"Start\" | \"End\" | \"Stretch\"",
+            "value": [
+              {
+                "value": "\"Center\"",
+                "description": "Popover is centered."
+              },
+              {
+                "value": "\"Start\"",
+                "description": "Popover is aligned with the start of the target."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Popover is aligned with the end of the target."
+              },
+              {
+                "value": "\"Stretch\"",
+                "description": "Popover is stretched."
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Stretch\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the horizontal alignment of the menu relative to its opener control.",
+          "defaultValue": {
+            "value": "\"Start\""
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if a loading indicator would be displayed inside the corresponding ui5-menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the loading indicator will be displayed inside the corresponding ui5-menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if the menu is open.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "opener": {
+          "type": {
+            "name": "string | HTMLElement"
+          },
+          "required": false,
+          "description": "Defines the ID or DOM Reference of the element at which the menu is shown.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**."
+        },
+        "placement": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Start\" | \"End\" | PopoverPlacement | \"Top\" | \"Bottom\"",
+            "value": [
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Start\"",
+                "description": "Popover will be placed at the start of the reference element."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Popover will be placed at the end of the reference element."
+              },
+              {
+                "value": "\"Top\"",
+                "description": "Popover will be placed at the top of the reference element."
+              },
+              {
+                "value": "\"Bottom\"",
+                "description": "Popover will be placed at the bottom of the reference element."
+              },
+              {
+                "value": "\"Top\""
+              },
+              {
+                "value": "\"Bottom\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines on which side the component is placed at.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Bottom\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<MenuDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "MenuItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "`MenuItem` is the item to use inside a `Menu`.\nAn arbitrary hierarchy structure can be represented by recursively nesting menu items.\n\n### Usage\n\n`MenuItem` represents a node in a `Menu`. The menu itself is rendered as a list,\nand each `MenuItem` is represented by a list item in that list. Therefore, you should only use\n`MenuItem` directly in your apps. The `ListItemStandard` list item is internal for the list, and not intended for public use.\n\n\n\n__Note:__ This is a UI5 Web Component! [MenuItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MenuItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of this component.\n\n**Note:** The slot can hold menu item and menu separator items.\n\nIf there are items added to this slot, an arrow will be displayed at the end\nof the item in order to indicate that there are items added. In that case components added\nto `endContent` slot or `additionalText` content will not be displayed.\n\nThe priority of what will be displayed at the end of the menu item is as follows:\nsub-menu arrow (if there are items added in `items` slot) -> components added in `endContent` -> text set to `additionalText`.\n\n__Supported Node Type/s:__ `Array<IMenuItem>`"
+        },
+        "deleteButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `Button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "endContent": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the components that should be displayed at the end of the menu item.\n\n**Note:** It is highly recommended to slot only components of type `Button`,`Link`\nor `Icon` in order to preserve the intended design. If there are components added to this slot,\nand there is text set in `additionalText`, it will not be displayed. If there are items added to `items` slot,\nnether `additionalText` nor components added to this slot would be displayed.\n\nThe priority of what will be displayed at the end of the menu item is as follows:\nsub-menu arrow (if there are items added in `items` slot) -> components added in `endContent` -> text set to `additionalText`.\n\nApplication developers are responsible for ensuring that interactive elements placed in the `endContent` slot\nhave the correct accessibility behaviour, including their enabled or disabled states.\nThe menu does not manage these aspects when the menu item state changes.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"endContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onBeforeClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MenuItemDomRef, MenuBeforeCloseEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the menu is closed. This event can be cancelled, which will prevent the menu from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "escPressed",
+                "type": "boolean",
+                "description": "Indicates that `ESC` key has triggered the event."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onBeforeOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MenuItemDomRef, MenuBeforeOpenEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the menu is opened. This event can be cancelled, which will prevent the menu from opening.\n\n**Note:** Since 1.14.0 the event is also fired before a sub-menu opens.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The menu item that triggers opening of the sub-menu or undefined when fired upon root menu opening."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onCheck": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MenuItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when an item is checked or unchecked.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MenuItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the menu is closed.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onDetailClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MenuItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MenuItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the menu is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "MenuItemAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaKeyShortcuts**: Indicated the availability of a keyboard shortcuts defined for the menu item.\n\n- **role**: Defines the role of the menu item. If not set, menu item will have default role=\"menuitem\".\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.7.0](https://github.com/UI5/webcomponents/releases/tag/v1.7.0) of **@ui5/webcomponents**."
+        },
+        "additionalText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `additionalText`, displayed in the end of the menu item.\n\n**Note:** The additional text will not be displayed if there are items added in `items` slot or there are\ncomponents added to `endContent` slot.\n\nThe priority of what will be displayed at the end of the menu item is as follows:\nsub-menu arrow (if there are items added in `items` slot) -> components added in `endContent` -> text set to `additionalText`.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents**."
+        },
+        "checked": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether menu item is in checked state.\n\n**Note:** checked state is only taken into account when menu item is added to menu item group\nwith `checkMode` other than `None`.\n\n**Note:** A checked menu item has a checkmark displayed at its end.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether menu item is in disabled state.\n\n**Note:** A disabled menu item is noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "highlight": {
+          "type": {
+            "name": "enum",
+            "raw": "Highlight | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\n**Example:**\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the loading indicator will be displayed inside the corresponding menu popover.\n\n**Note:** If set to `true` a busy indicator component will be displayed into the related one to the current menu item sub-menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the loading indicator will be displayed inside the corresponding menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "navigated": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tree item."
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tooltip for the menu item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
+            "value": [
+              {
+                "value": "\"Inactive\"",
+                "description": "Indicates the list item does not have any active feedback when item is pressed."
+              },
+              {
+                "value": "\"Active\"",
+                "description": "Indicates that the item is clickable via active feedback when item is pressed."
+              },
+              {
+                "value": "\"Detail\"",
+                "description": "Enables detail button of the list item that fires detail-click event."
+              },
+              {
+                "value": "\"Navigation\"",
+                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
+              },
+              {
+                "value": "\"Inactive\""
+              },
+              {
+                "value": "\"Active\""
+              },
+              {
+                "value": "\"Detail\""
+              },
+              {
+                "value": "\"Navigation\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
+          "defaultValue": {
+            "value": "\"Active\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<MenuItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "MenuItemGroup": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `MenuItemGroup` component represents a group of items designed for use inside a `Menu`.\nItems belonging to the same group should be wrapped by a `MenuItemGroup`.\nEach group can have an `checkMode` property, which defines the check mode for the items within the group.\nThe possible values for `checkMode` are:\n- 'None' (default) - no items can be checked\n- 'Single' - Only one item can be checked at a time\n- 'Multiple' - Multiple items can be checked simultaneously\n\n**Note:** If the `checkMode` property is set to 'Single', only one item can remain checked at any given time.\nIf multiple items are marked as checked, the last checked item will take precedence.\n\n### Usage\n\n`MenuItemGroup` represents a collection of `MenuItem` components that can have the same check mode.\nThe items are addeed to the group's `items` slot.\n\n\n\n__Note:__ This is a UI5 Web Component! [MenuItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MenuItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of this component.\n**Note:** The slot can hold any combination of components of type `MenuItem` or `MenuSeparator` or both.\n\n__Supported Node Type/s:__ `Array<IMenuItem>`"
+        },
+        "checkMode": {
+          "type": {
+            "name": "enum",
+            "raw": "MenuItemGroupCheckMode | \"None\" | \"Single\" | \"Multiple\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "default type (items in a group cannot be checked)"
+              },
+              {
+                "value": "\"Single\"",
+                "description": "Single item check mode (only one item in a group can be checked at a time)"
+              },
+              {
+                "value": "\"Multiple\"",
+                "description": "Multiple items check mode (multiple items in a group can be checked at a time)"
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Single\""
+              },
+              {
+                "value": "\"Multiple\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component's check mode.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<MenuItemGroupDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "MenuSeparator": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `MenuSeparator` represents a horizontal line to separate menu items inside a `Menu`.\n\n__Note:__ This is a UI5 Web Component! [MenuSeparator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MenuSeparator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<MenuSeparatorDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "MessageStrip": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The ui5-message-strip component allows for the embedding of application-related messages.\nIt supports four semantic designs, each with its own color and icon: \"Information\", \"Positive\", \"Critical\", and \"Negative\".\nAdditionally, users can choose from two color sets (\"ColorSet1\" and \"ColorSet2\"), each containing 10 predefined color schemes.\nEach message shows a \"Close\" button, so that it can be removed from the UI, if needed.\n\n### Usage\n\nFor the `MessageStrip` component, you can define whether it displays\nan icon in the beginning and a close button. Moreover, its size and background\ncan be controlled with CSS.\n\n### Keyboard Handling\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [MessageStrip UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MessageStrip) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "icon": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content to be displayed as graphical element within the component.\n\n**Note:** If no icon is given, the default icon for the component type will be used.\nThe SAP-icons font provides numerous options.\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html).\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MessageStripDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the close button is pressed either with a\nclick/tap or by using the Enter or Space key.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "colorScheme": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the color scheme of the component.\nThere are 10 predefined schemes.\nTo use one you can set a number from `\"1\"` to `\"10\"`. The `colorScheme` `\"1\"` will be set by default.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"1\""
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "MessageStripDesign | \"Information\" | \"Positive\" | \"Negative\" | \"Critical\" | \"ColorSet1\" | \"ColorSet2\"",
+            "value": [
+              {
+                "value": "\"Information\"",
+                "description": "Message should be just an information"
+              },
+              {
+                "value": "\"Positive\"",
+                "description": "Message is a success message"
+              },
+              {
+                "value": "\"Negative\"",
+                "description": "Message is an error"
+              },
+              {
+                "value": "\"Critical\"",
+                "description": "Message is a warning"
+              },
+              {
+                "value": "\"ColorSet1\"",
+                "description": "Message uses custom color set 1"
+              },
+              {
+                "value": "\"ColorSet2\"",
+                "description": "Message uses custom color set 2"
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"ColorSet1\""
+              },
+              {
+                "value": "\"ColorSet2\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component type.",
+          "defaultValue": {
+            "value": "\"Information\""
+          }
+        },
+        "hideCloseButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the MessageStrip renders close button.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the MessageStrip will show an icon in the beginning.\nYou can directly provide an icon with the `icon` slot. Otherwise, the default icon for the type will be used.\n\n * **Note:** If <code>MessageStripDesign.ColorSet1</code> or <code>MessageStripDesign.ColorSet2</code> value is set to the <code>design</code> property, default icon will not be presented.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<MessageStripDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "MultiComboBox": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `MultiComboBox` component consists of a list box with items and a text field allowing the user to either type a value directly into the text field, or choose from the list of existing items.\n\nThe drop-down list is used for selecting and filtering values, it enables users to select one or more options from a predefined list. The control provides an editable input field to filter the list, and a dropdown arrow to expand/collapse the list of available options.\nThe options in the list have checkboxes that permit multi-selection. Entered values are displayed as tokens.\n### Structure\nThe `MultiComboBox` consists of the following elements:\n\n-  Tokenizer - a list of tokens with selected options.\n-  Input field - displays the selected option/s as token/s. Users can type to filter the list.\n-  Drop-down arrow - expands\\collapses the option list.\n-  Option list - the list of available options.\n\n### Keyboard Handling\n\nThe `MultiComboBox` provides advanced keyboard handling.\n\n#### Picker\nIf the `MultiComboBox` is focused,\nyou can open or close the drop-down by pressing [F4], [Alt] + [Up] or [Alt] + [Down] keys.\nOnce the drop-down is opened, you can use the `UP` and `DOWN` arrow keys\nto navigate through the available options and select one by pressing the `Space` or `Enter` keys.\n[Ctrl]+[Alt]+[F8] or [Command]+[Option]+[F8] - Focuses the first link in the value state message, if available. Pressing [Tab] moves the focus to the next link in the value state message, or closes the value state message if there are no more links.\n\n#### Tokens\n\n-  Left/Right arrow keys - moves the focus selection form the currently focused token to the previous/next one (if available).\n-  Delete -  deletes the token and focuses the previous token.\n-  Backspace -  deletes the token and focus the next token.\n\n\n\n__Note:__ This is a UI5 Web Component! [MultiComboBox UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MultiComboBox) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the component items.\n\n__Supported Node Type/s:__ `Array<IMultiComboBoxItem>`"
+        },
+        "icon": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed in the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
+        },
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the dropdown is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the component changes at each keystroke or clear icon is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the dropdown is opened.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, MultiComboBoxSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when selection is changed by user interaction.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "items",
+                "type": "Array<IMultiComboBoxItem>",
+                "description": "an array of the selected items."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onValueStateChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, MultiComboBoxValueStateChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the value state of the component is updated internally.\nThe event is preventable, meaning that if it's default action is\nprevented, the component will not update the value state.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valueState",
+                "type": "string",
+                "description": "The new `valueState` that will be set."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "filter": {
+          "type": {
+            "name": "enum",
+            "raw": "ComboBoxFilter | \"StartsWithPerTerm\" | \"StartsWith\" | \"Contains\" | \"None\"",
+            "value": [
+              {
+                "value": "\"StartsWithPerTerm\"",
+                "description": "Defines filtering by first symbol of each word of item's text."
+              },
+              {
+                "value": "\"StartsWith\"",
+                "description": "Defines filtering by starting symbol of item's text."
+              },
+              {
+                "value": "\"Contains\"",
+                "description": "Defines contains filtering."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Removes any filtering applied while typing"
+              },
+              {
+                "value": "\"StartsWithPerTerm\""
+              },
+              {
+                "value": "\"StartsWith\""
+              },
+              {
+                "value": "\"Contains\""
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the filter type of the component.",
+          "defaultValue": {
+            "value": "\"StartsWithPerTerm\""
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether a loading indicator should be shown in the picker.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n**Note:** When the component is used inside a form element,\nthe value is sent as the first element in the form data, even if it's empty.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
+        },
+        "noTypeahead": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the value will be autcompleted to match an item\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "noValidation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the user input will be prevented, if no matching item has been found",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the items picker is open.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selectedValues": {
+          "type": {
+            "name": "string[]"
+          },
+          "required": false,
+          "description": "Defines the values of the selected items.\n\nUse this property to programmatically select items by their `value` property.\nEach string in the array should match the `value` attribute of a `MultiComboBoxItem`.\n\n**Note:** If an item doesn't have a `value` attribute set, it cannot be selected via this property.\n\n**Note:** The recommended approach is to set the `value` property on each `MultiComboBoxItem`\nand use `selectedValues` for programmatic selection. The `selected` property on items is\ndeprecated and should not be used together with `selectedValues`.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "[]"
+          }
+        },
+        "showClearIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the clear icon of the multi-combobox will be shown.\n\n**Note:** Available since [v1.20.1](https://github.com/UI5/webcomponents/releases/tag/v1.20.1) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showSelectAll": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines if the select all checkbox is visible on top of suggestions.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<MultiComboBoxDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "token-\\{index\\}",
+          "description": "Used to style each token(where `token-0` corresponds to the first item)"
+        }
+      ]
+    },
+    "MultiComboBoxItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `MultiComboBoxItem` represents the item for a `MultiComboBox`.\n\n__Note:__ This is a UI5 Web Component! [MultiComboBoxItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MultiComboBoxItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "additionalText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the additional text of the component."
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.\n@deprecated Set the `value` property on items and use the `selectedValues` property on the parent `ui5-multi-combobox` instead for programmatic selection.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the component."
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component.\n\nUse this property to associate a unique identifier with the item,\nseparate from the display text. This enables selecting items\nprogrammatically via `selectedValues` on the parent MultiComboBox.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<MultiComboBoxItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "MultiComboBoxItemGroup": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `MultiComboBoxItemGroup` is type of suggestion item,\nthat can be used to split the `MultiComboBox` suggestions into groups.\n\n__Note:__ This is a UI5 Web Component! [MultiComboBoxItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MultiComboBoxItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the <code>ui5-mcb-item-group</code>.\n\n__Supported Node Type/s:__ `Array<MultiComboBoxItem>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
+        },
+        "onMove": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiComboBoxItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMoveOver": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiComboBoxItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "headerAccessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the header."
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text of the <code>ui5-li-group</code>."
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "WrappingType | \"None\" | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ExpandableText` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<MultiComboBoxItemGroupDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "header",
+          "description": "Used to style the header item of the group"
+        },
+        {
+          "name": "title",
+          "description": "Used to style the title of the group header"
+        }
+      ]
+    },
+    "MultiInput": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A `MultiInput` field allows the user to enter multiple values, which are displayed as `Token`.\n\nUser can choose interaction for creating tokens.\nFiori Guidelines say that user should create tokens when:\n\n- Type a value in the input and press enter or focus out the input field (`change` event is fired)\n- Move between suggestion items (`selection-change` event is fired)\n- Clicking on a suggestion item (`selection-change` event is fired if the clicked item is different than the current value. Also `change` event is fired )\n\n\n\n__Note:__ This is a UI5 Web Component! [MultiInput UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MultiInput) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the suggestion items.\n\n**Note:** The suggestions would be displayed only if the `showSuggestions`\nproperty is set to `true`.\n\n**Note:** The `<SuggestionItem>`, `<SuggestionItemGroup>` and `SuggestionItemCustom` are recommended to be used as suggestion items.\n\n__Supported Node Type/s:__ `Array<IInputSuggestionItem>`"
+        },
+        "icon": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed in the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
+        },
+        "tokens": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the component tokens.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"tokens\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IToken>`"
+        },
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n**Note:** If the component has `suggestionItems`,\nthe `valueStateMessage` would be displayed as part of the same popover, if used on desktop, or dialog - on phone.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the suggestions picker is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the component changes at each keystroke,\nand when a suggestion item has been selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the suggestions picker is open.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSelect": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when some text has been selected.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiInputDomRef, InputSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user navigates to a suggestion item via the ARROW keys,\nas a preview, before the final selection.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The previewed suggestion item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onTokenDelete": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiInputDomRef, MultiInputTokenDeleteEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when tokens are being deleted.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "tokens",
+                "type": "Array",
+                "description": "An array containing the deleted tokens."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onValueHelpTrigger": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value help icon is pressed\nand F4 or ALT/OPTION + ARROW_UP/ARROW_DOWN keyboard keys are used.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the input."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "filter": {
+          "type": {
+            "name": "enum",
+            "raw": "InputSuggestionsFilter | \"StartsWithPerTerm\" | \"StartsWith\" | \"Contains\" | \"None\"",
+            "value": [
+              {
+                "value": "\"StartsWithPerTerm\"",
+                "description": "Defines filtering by first symbol of each word of item's text."
+              },
+              {
+                "value": "\"StartsWith\"",
+                "description": "Defines filtering by starting symbol of item's text."
+              },
+              {
+                "value": "\"Contains\"",
+                "description": "Defines contains filtering."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Removes any filtering applied while typing"
+              },
+              {
+                "value": "\"StartsWithPerTerm\""
+              },
+              {
+                "value": "\"StartsWith\""
+              },
+              {
+                "value": "\"Contains\""
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the filter type of the component.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "maxlength": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Sets the maximum number of characters available in the input field.\n\n**Note:** This property is not compatible with the ui5-input type InputType.Number. If the ui5-input type is set to Number, the maxlength value is ignored."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n**Note:** When the component is used inside a form element,\nthe value is sent as the first element in the form data, even if it's empty."
+        },
+        "noTypeahead": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the value will be autcompleted to match an item\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the suggestions picker is open.\nThe picker will not open if the `showSuggestions` property is set to `false`, the input is disabled or the input is readonly.\nThe picker will close automatically and `close` event will be fired if the input is not in the viewport.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showClearIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showSuggestions": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should show suggestions, if such are present.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showValueHelpIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether a value help icon will be visualized in the end of the input.\nPressing the icon will fire `value-help-trigger` event.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "InputType | \"Text\" | \"Email\" | \"Number\" | \"Password\" | \"Tel\" | \"URL\" | \"Search\"",
+            "value": [
+              {
+                "value": "\"Text\"",
+                "description": "Defines a one-line text input field:"
+              },
+              {
+                "value": "\"Email\"",
+                "description": "Used for input fields that must contain an e-mail address."
+              },
+              {
+                "value": "\"Number\"",
+                "description": "Defines a numeric input field."
+              },
+              {
+                "value": "\"Password\"",
+                "description": "Defines a password field."
+              },
+              {
+                "value": "\"Tel\"",
+                "description": "Used for input fields that should contain a telephone number."
+              },
+              {
+                "value": "\"URL\"",
+                "description": "Used for input fields that should contain a URL address."
+              },
+              {
+                "value": "\"Search\"",
+                "description": "Used for input fields that should contain a search term."
+              },
+              {
+                "value": "\"Text\""
+              },
+              {
+                "value": "\"Email\""
+              },
+              {
+                "value": "\"Number\""
+              },
+              {
+                "value": "\"Password\""
+              },
+              {
+                "value": "\"Tel\""
+              },
+              {
+                "value": "\"URL\""
+              },
+              {
+                "value": "\"Search\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the HTML type of the component.\n\n**Notes:**\n\n- The particular effect of this property differs depending on the browser\nand the current language settings, especially for type `Number`.\n- The property is mostly intended to be used with touch devices\nthat use different soft keyboard layouts depending on the given input type.",
+          "defaultValue": {
+            "value": "\"Text\""
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<MultiInputDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "clear-icon",
+          "description": "Used to style the clear icon, which can be pressed to clear user input text"
+        },
+        {
+          "name": "input",
+          "description": "Used to style the native input element"
+        },
+        {
+          "name": "root",
+          "description": "Used to style the root DOM element of the Input component"
+        }
+      ]
+    },
+    "NavigationLayout": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `NavigationLayout` is a container component that can be used to\ncreate a layout with a header, a side navigation and a content area.\n\n### Usage\n\nUse the `NavigationLayout` to create whole screen of an application with vertical navigation.\n\n### Responsive Behavior\n\nOn larger screens with a width of 600px or more, excluding mobile phone devices, the side navigation is visible\nby default and can be expanded or collapsed using the `mode` property.\nOn mobile phone devices and screens with a width of 599px or less, the side navigation is hidden by\ndefault and can be displayed using the `mode` property.\n\n\n\n__Note:__ This is a UI5 Web Component! [NavigationLayout UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/NavigationLayout) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "sideContent": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the side content.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"sideContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<SideNavigation>`"
+        },
+        "mode": {
+          "type": {
+            "name": "enum",
+            "raw": "NavigationLayoutMode | \"Auto\" | \"Collapsed\" | \"Expanded\"",
+            "value": [
+              {
+                "value": "\"Auto\"",
+                "description": "Automatically calculates the navigation layout mode based on the screen width.\n`Collapsed` on small screens (screen width of 599px or less) and `Expanded` on larger screens (screen width of 600px or more)."
+              },
+              {
+                "value": "\"Collapsed\"",
+                "description": "Collapsed side navigation."
+              },
+              {
+                "value": "\"Expanded\"",
+                "description": "Expanded side navigation."
+              },
+              {
+                "value": "\"Auto\""
+              },
+              {
+                "value": "\"Collapsed\""
+              },
+              {
+                "value": "\"Expanded\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Specifies the navigation layout mode.",
+          "defaultValue": {
+            "value": "\"Auto\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<NavigationLayoutDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "isSideCollapsed",
+          "description": "Gets whether the side navigation is collapsed.",
+          "params": [],
+          "returns": {
+            "type": "boolean"
+          }
+        }
+      ]
+    },
+    "NotificationList": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `NotificationList` web component represents\na container for `NotificationListGroupItem` and `NotificationListItem`.\n\n### Keyboard Handling\n\n#### Basic Navigation\nThe `NotificationList` provides advanced keyboard handling.\nWhen a list is focused the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Up] or [Left] - Navigates up the items\n- [Down] or [Right] - Navigates down the items\n- [Home] - Navigates to first item\n- [End] - Navigates to the last item\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [NotificationList UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/NotificationList) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the component.\n\n__Supported Node Type/s:__ `Array<NotificationListItemBase>`"
+        },
+        "onItemClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<NotificationListDomRef, NotificationItemEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when an item is clicked.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The clicked item."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onItemClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<NotificationListDomRef, NotificationItemEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `Close` button of any item is clicked.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "the item about to be closed."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onItemToggle": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<NotificationListDomRef, NotificationItemEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when an item is toggled.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "the toggled item."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "noDataText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text that is displayed when the component contains no items."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<NotificationListDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "NotificationListGroupItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `NotificationListGroupItem` is a special type of list item,\nthat unlike others can group items within self, usually `NotificationListItem` items.\n\nThe component consists of:\n\n- `Toggle` button to expand and collapse the group\n- `TitleText` to entitle the group\n- Items of the group\n\n### Usage\nThe component should be used inside a `NotificationList`.\n\n### Keyboard Handling\nThe `NotificationListGroupItem` provides advanced keyboard handling.\nThis component provides fast navigation when the header is focused using the following keyboard shortcuts:\n\n- [Space] - toggles expand / collapse of the group\n- [Plus] - expands the group\n- [Minus] - collapses the group\n- [Right] - expands the group\n- [Left] - collapses the group\n\n\n\n__Note:__ This is a UI5 Web Component! [NotificationListGroupItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/NotificationListGroupItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the `NotificationListGroupItem`,\nusually `NotificationListItem` items.\n\n__Supported Node Type/s:__ `Array<NotificationListItem>`"
+        },
+        "onLoadMore": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<NotificationListGroupItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when additional items are requested.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onToggle": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<NotificationListGroupItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `NotificationListGroupItem` is expanded/collapsed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "collapsed": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the group is collapsed or expanded.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "growing": {
+          "type": {
+            "name": "enum",
+            "raw": "NotificationListGrowingMode | \"Button\" | \"None\"",
+            "value": [
+              {
+                "value": "\"Button\"",
+                "description": "Component's \"load-more\" is fired upon pressing a \"More\" button.\nat the bottom."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Component's growing is not enabled."
+              },
+              {
+                "value": "\"Button\""
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines whether the component will have growing capability by pressing a `More` button.\nWhen button is pressed `load-more` event will be fired.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if a busy indicator would be displayed over the item.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the busy indicator will show up for this component.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "read": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the `notification` is new or has been already read.\n\n**Note:** if set to `false` the `titleText` has bold font,\nif set to true - it has a normal font.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `titleText` of the item."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<NotificationListGroupItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "NotificationListItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `NotificationListItem` is a type of list item, meant to display notifications.\n\nThe component has a rich set of various properties that allows the user to set `avatar`, `menu`, `titleText`, descriptive `content`\nand `footnotes` to fully describe a notification.\n\nThe user can:\n\n- display a `Close` button\n- can control whether the `titleText` and `description` should wrap or truncate\nand display a `ShowMore` button to switch between less and more information\n- add actions by using the `ui5-menu` component\n\n**Note:** Adding custom actions by using the `ui5-notification-action` component is deprecated as of version 2.0!\n\n### Usage\nThe component should be used inside a `NotificationList`.\n\n### Keyboard Handling\n\n#### Basic Navigation\nThe user can use the following keyboard shortcuts to perform actions (such as select, delete):\n\n- [Enter] - select an item (trigger \"item-click\" event)\n- [Delete] - close an item (trigger \"item-close\" event)\n\n#### Fast Navigation\nThis component provides a fast navigation using the following keyboard shortcuts:\n\n- [Shift] + [Enter] - 'More'/'Less' link will be triggered\n- [Shift] + [F10] - 'Menu' (Actions) button will be triggered (clicked)\n\n\n\n__Note:__ This is a UI5 Web Component! [NotificationListItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/NotificationListItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "avatar": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the avatar, displayed in the `NotificationListItem`.\n\n**Note:** Consider using the `ui5-avatar` to display icons, initials or images.\n\n**Note:** In order to be complaint with the UX guidlines and for best experience,\nwe recommend using avatars with 2rem X 2rem in size (32px X 32px). In case you are using the `ui5-avatar`\nyou can set its `size` property to `XS` to get the required size - `<ui5-avatar size=\"XS\"></ui5-avatar>`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"avatar\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the `NotificationListItem`,\nusually a description of the notification.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "footnotes": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the elements, displayed in the footer of the of the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footnotes\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "menu": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the menu, displayed in the `NotificationListItem`.\n\n**Note:** Use this for implementing actions.\n\n**Note:** Should be used instead `u5-notification-action`, which is deprecated as of version 2.0.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"menu\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<NotificationListItemDomRef, NotificationListItemCloseEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `Close` button is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "the closed item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": false
+          }
+        },
+        "importance": {
+          "type": {
+            "name": "enum",
+            "raw": "NotificationListItemImportance | \"Standard\" | \"Important\"",
+            "value": [
+              {
+                "value": "\"Standard\""
+              },
+              {
+                "value": "\"Important\""
+              },
+              {
+                "value": "\"Standard\""
+              },
+              {
+                "value": "\"Important\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the `Important` label of the item.",
+          "defaultValue": {
+            "value": "\"Standard\""
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if a busy indicator would be displayed over the item.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the busy indicator will show up for this component.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "read": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the `notification` is new or has been already read.\n\n**Note:** if set to `false` the `titleText` has bold font,\nif set to true - it has a normal font.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showClose": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the `Close` button would be displayed.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "state": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the status indicator of the item.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `titleText` of the item."
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | WrappingType | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines if the `titleText` and `description` should wrap,\nthey truncate by default.\n\n**Note:** by default the `titleText` and `description`,\nand a `ShowMore/Less` button would be displayed.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<NotificationListItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "title-text",
+          "description": "Used to style the titleText of the notification list item"
+        }
+      ]
+    },
+    "Option": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Option` component defines the content of an option in the `Select`.\n\n\n\n__Note:__ This is a UI5 Web Component! [Option UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Option) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "additionalText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `additionalText`, displayed in the end of the option."
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `icon` source URI.\n\n**Note:**\nSAP-icons font provides numerous built-in icons. To find all the available icons, see the\n[Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.\n@deprecated since 2.20.0, please use the parent Select's `value` property instead.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the option.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the `Select` inside an HTML Form element when this component is selected.\nFor more information on HTML Form support, see the `name` property of `Select`."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<OptionDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "OptionCustom": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `OptionCustom` component defines a custom content of an option in the `Select`.\nA component to be the same way as the standard `Option`.\nThe component accepts arbitrary HTML content to allow full customization.\n\n\n\n__Note:__ This is a UI5 Web Component! [OptionCustom UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/OptionCustom) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "displayText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text, displayed inside the `Select` input filed\nwhen the option gets selected."
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the option."
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the `Select` inside an HTML Form element when this component is selected.\nFor more information on HTML Form support, see the `name` property of `Select`."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<OptionCustomDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Page": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Page` is a container component that holds one whole screen of an application.\nThe page has three distinct areas that can hold content - a header, content area and a footer.\n### Structure\n#### Header\nThe top most area of the page is occupied by the header. The standard header includes a navigation button and a title.\n#### Content\nThe content occupies the main part of the page. Only the content area is scrollable by default.\nThis can be prevented by setting `noScrolling` to `true`.\n#### Footer\nThe footer is optional and occupies the part above the bottom part of the content. Alternatively, the footer can be fixed at the bottom of the page by enabling the `fixedFooter` property.\n\n**Note:** `Page` occipues the whole available space of its parent. In order to achieve the intended design you have to make sure\nthat there is enough space for the `Page` to be rendered.\n**Note:** In order for the `Page` to be displayed, the parent element should have fixed height.\n\n\n\n__Note:__ This is a UI5 Web Component! [Page UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/Page) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content HTML Element.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "footer": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the footer HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "backgroundDesign": {
+          "type": {
+            "name": "enum",
+            "raw": "PageBackgroundDesign | \"List\" | \"Solid\" | \"Transparent\"",
+            "value": [
+              {
+                "value": "\"List\"",
+                "description": "Page background color when a List is set as the Page content."
+              },
+              {
+                "value": "\"Solid\"",
+                "description": "A solid background color dependent on the theme."
+              },
+              {
+                "value": "\"Transparent\"",
+                "description": "Transparent background for the page."
+              },
+              {
+                "value": "\"List\""
+              },
+              {
+                "value": "\"Solid\""
+              },
+              {
+                "value": "\"Transparent\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the background color of the `Page`.\n\n**Note:** When a ui5-list is placed inside the page, we recommend using “List” to ensure better color contrast.",
+          "defaultValue": {
+            "value": "\"Solid\""
+          }
+        },
+        "fixedFooter": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the footer is fixed at the very bottom of the page.\n\n**Note:** When set to true the footer is fixed at the very bottom of the page, otherwise it floats over the content with a slight offset from the bottom.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideFooter": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the footer visibility.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "noScrolling": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Disables vertical scrolling of page content.\nIf set to true, there will be no vertical scrolling at all.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<PageDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "content",
+          "description": "Used to style the content section of the component"
+        }
+      ]
+    },
+    "Panel": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Panel` component is a container which has a header and a\ncontent area and is used\nfor grouping and displaying information. It can be collapsed to save space on the screen.\n\n### Guidelines:\n\n- Nesting two or more panels is not recommended.\n- Do not stack too many panels on one page.\n\n### Structure\nThe panel's header area consists of a title bar with a header text or custom header.\n\nThe header is clickable and can be used to toggle between the expanded and collapsed state. It includes an icon which rotates depending on the state.\n\nThe custom header can be set through the `header` slot and it may contain arbitraray content, such as: title, buttons or any other HTML elements.\n\nThe content area can contain an arbitrary set of controls.\n\n**Note:** The custom header is not clickable out of the box, but in this case the icon is interactive and allows to show/hide the content area.\n\n### Responsive Behavior\n\n- If the width of the panel is set to 100% (default), the panel and its children are\nresized responsively,\ndepending on its parent container.\n- If the panel has a fixed height, it will take up the space even if the panel is\ncollapsed.\n- When the panel is expandable (the `fixed` property is set to `false`),\nan arrow icon (pointing to the right) appears in front of the header.\n- When the animation is activated, expand/collapse uses a smooth animation to open or\nclose the content area.\n- When the panel expands/collapses, the arrow icon rotates 90 degrees\nclockwise/counter-clockwise.\n\n### Keyboard Handling\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [Panel UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Panel) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component. The content is visible only when the component is expanded.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the component header area.\n\n**Note:** When a header is provided, the `headerText` property is ignored.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onToggle": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<PanelDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is expanded/collapsed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "PanelAccessibleRole | \"Complementary\" | \"Form\" | \"Region\"",
+            "value": [
+              {
+                "value": "\"Complementary\"",
+                "description": "Represents the ARIA role \"complementary\".\nA section of the page, designed to be complementary to the main content at a similar level in the DOM hierarchy."
+              },
+              {
+                "value": "\"Form\"",
+                "description": "Represents the ARIA role \"Form\".\nA landmark region that contains a collection of items and objects that, as a whole, create a form."
+              },
+              {
+                "value": "\"Region\"",
+                "description": "Represents the ARIA role \"Region\".\nA section of a page, that is important enough to be included in a page summary or table of contents."
+              },
+              {
+                "value": "\"Complementary\""
+              },
+              {
+                "value": "\"Form\""
+              },
+              {
+                "value": "\"Region\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Sets the accessible ARIA role of the component.\nDepending on the usage, you can change the role from the default `Form`\nto `Region` or `Complementary`.",
+          "defaultValue": {
+            "value": "\"Form\""
+          }
+        },
+        "collapsed": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the component is collapsed and only the header is displayed.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "fixed": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is in a fixed state that is not\nexpandable/collapsible by user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "headerLevel": {
+          "type": {
+            "name": "enum",
+            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
+            "value": [
+              {
+                "value": "\"H1\"",
+                "description": "Renders `h1` tag."
+              },
+              {
+                "value": "\"H2\"",
+                "description": "Renders `h2` tag."
+              },
+              {
+                "value": "\"H3\"",
+                "description": "Renders `h3` tag."
+              },
+              {
+                "value": "\"H4\"",
+                "description": "Renders `h4` tag."
+              },
+              {
+                "value": "\"H5\"",
+                "description": "Renders `h5` tag."
+              },
+              {
+                "value": "\"H6\"",
+                "description": "Renders `h6` tag."
+              },
+              {
+                "value": "\"H1\""
+              },
+              {
+                "value": "\"H2\""
+              },
+              {
+                "value": "\"H3\""
+              },
+              {
+                "value": "\"H4\""
+              },
+              {
+                "value": "\"H5\""
+              },
+              {
+                "value": "\"H6\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the \"aria-level\" of component heading,\nset by the `headerText`.",
+          "defaultValue": {
+            "value": "\"H2\""
+          }
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "This property is used to set the header text of the component.\nThe text is visible in both expanded and collapsed states.\n\n**Note:** This property is overridden by the `header` slot."
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the transition between the expanded and the collapsed state of the component is animated. By default the animation is enabled.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "stickyHeader": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the Panel header is sticky or not.\nIf stickyHeader is set to true, then whenever you scroll the content or\nthe application, the header of the panel will be always visible and\na solid color will be used for its design.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<PanelDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "content",
+          "description": "Used to style the wrapper of the content."
+        },
+        {
+          "name": "header",
+          "description": "Used to style the wrapper of the header."
+        }
+      ]
+    },
+    "Popover": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Popover` component displays additional information for an object\nin a compact way and without leaving the page.\nThe Popover can contain various UI elements, such as fields, tables, images, and charts.\nIt can also include actions in the footer.\n\n### Structure\n\nThe popover has three main areas:\n\n- Header (optional)\n- Content\n- Footer (optional)\n\n**Note:** The `Popover` is closed when the user clicks\nor taps outside the popover\nor selects an action within the popover. You can prevent this with the\n`modal` property.\n\n\n\n__Note:__ This is a UI5 Web Component! [Popover UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Popover) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the Popup.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "footer": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the footer HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onBeforeClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<PopoverDomRef, PopupBeforeCloseEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "escPressed",
+                "type": "boolean",
+                "description": "Indicates that `ESC` key has triggered the event."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onBeforeOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<PopoverDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<PopoverDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<PopoverDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "PopupAccessibleRole | \"None\" | \"Dialog\" | \"AlertDialog\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "Represents no ARIA role."
+              },
+              {
+                "value": "\"Dialog\"",
+                "description": "Represents the ARIA role \"dialog\"."
+              },
+              {
+                "value": "\"AlertDialog\"",
+                "description": "Represents the ARIA role \"alertdialog\"."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Dialog\""
+              },
+              {
+                "value": "\"AlertDialog\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Dialog\""
+          }
+        },
+        "allowTargetOverlap": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines if there is no enough space, the component can be placed\nover the target.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text.\n\n**Note:** If `header` slot is provided, the `headerText` is ignored."
+        },
+        "hideArrow": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component arrow is hidden.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "horizontalAlign": {
+          "type": {
+            "name": "enum",
+            "raw": "PopoverHorizontalAlign | \"Center\" | \"Start\" | \"End\" | \"Stretch\"",
+            "value": [
+              {
+                "value": "\"Center\"",
+                "description": "Popover is centered."
+              },
+              {
+                "value": "\"Start\"",
+                "description": "Popover is aligned with the start of the target."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Popover is aligned with the end of the target."
+              },
+              {
+                "value": "\"Stretch\"",
+                "description": "Popover is stretched."
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Stretch\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the horizontal alignment of the component.",
+          "defaultValue": {
+            "value": "\"Center\""
+          }
+        },
+        "initialFocus": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the ID of the HTML Element, which will get the initial focus.\n\n**Note:** If an element with `autofocus` attribute is added inside the component,\n`initialFocus` won't take effect."
+        },
+        "modal": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should close when\nclicking/tapping outside the popover.\nIf enabled, it blocks any interaction with the background.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if the element is open\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "opener": {
+          "type": {
+            "name": "string | HTMLElement"
+          },
+          "required": false,
+          "description": "Defines the ID or DOM Reference of the element at which the popover is shown.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
+        },
+        "placement": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Start\" | \"End\" | PopoverPlacement | \"Top\" | \"Bottom\"",
+            "value": [
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Start\"",
+                "description": "Popover will be placed at the start of the reference element."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Popover will be placed at the end of the reference element."
+              },
+              {
+                "value": "\"Top\"",
+                "description": "Popover will be placed at the top of the reference element."
+              },
+              {
+                "value": "\"Bottom\"",
+                "description": "Popover will be placed at the bottom of the reference element."
+              },
+              {
+                "value": "\"Top\""
+              },
+              {
+                "value": "\"Bottom\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines on which side the component is placed at.",
+          "defaultValue": {
+            "value": "\"End\""
+          }
+        },
+        "preventFocusRestore": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "preventInitialFocus": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "resizable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is resizable.\n**Note:** This property is effective only on desktop devices.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "verticalAlign": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Center\" | \"Stretch\" | \"Top\" | \"Bottom\" | PopoverVerticalAlign",
+            "value": [
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Stretch\""
+              },
+              {
+                "value": "\"Top\""
+              },
+              {
+                "value": "\"Bottom\""
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Top\"",
+                "description": "Popover will be placed at the top of the reference control."
+              },
+              {
+                "value": "\"Bottom\"",
+                "description": "Popover will be placed at the bottom of the reference control."
+              },
+              {
+                "value": "\"Stretch\"",
+                "description": "Popover will be streched"
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the vertical alignment of the component.",
+          "defaultValue": {
+            "value": "\"Center\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<PopoverDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "applyFocus",
+          "description": "Focuses the element denoted by `initialFocus`, if provided, or the first focusable element otherwise.",
+          "params": [],
+          "returns": {
+            "type": "Promise<void>"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "content",
+          "description": "Used to style the content of the component"
+        },
+        {
+          "name": "footer",
+          "description": "Used to style the footer of the component"
+        },
+        {
+          "name": "header",
+          "description": "Used to style the header of the component"
+        }
+      ]
+    },
+    "ProductSwitch": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ProductSwitch` is an SAP Fiori specific web component that is used in `ShellBar`\nand allows the user to easily switch between products.\n\n### Keyboard Handling\nThe `ProductSwitch` provides advanced keyboard handling.\nWhen focused, the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Tab] - Move focus to the next interactive element after the `ProductSwitch`\n- [Up] or [Down] - Navigates up and down the items\n- [Left] or [Right] - Navigates left and right the items\n\n\n\n`import \"@ui5/webcomponents-fiori/dist/ProductSwitchItem.js\";` (for `ProductSwitchItem`)\n\n__Note:__ This is a UI5 Web Component! [ProductSwitch UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ProductSwitch) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the `ProductSwitch`.\n\n__Supported Node Type/s:__ `Array<IProductSwitchItem>`"
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ProductSwitchDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ProductSwitchItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ProductSwitchItem` web component represents the items displayed in the\n`ProductSwitch` web component.\n\n**Note:** `ProductSwitchItem` is not supported when used outside of `ProductSwitch`.\n\n### Keyboard Handling\nThe `ProductSwitch` provides advanced keyboard handling.\nWhen focused, the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Space] / [Enter] or [Return] - Trigger `ui5-click` event\n\n\n\n__Note:__ This is a UI5 Web Component! [ProductSwitchItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ProductSwitchItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "image": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines an image to be displayed instead of the standard icon.\n\n**Note:** The image slot takes precedence over the icon property.\n**Note:** We recommend using non-interactive ui5-avatar with size S, Square shape and Transparent colorScheme for best alignment.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"image\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ProductSwitchItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `ProductSwitchItem` is activated either with a\nclick/tap or by using the Enter or Space key.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed as a graphical element within the component.\n\nExample:\n\n`<ProductSwitchItem icon=\"palette\">`\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "subtitleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the subtitle of the component."
+        },
+        "target": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a target where the `targetSrc` content must be open.\n\nAvailable options are:\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `_search`\n\n**Note:** By default target will be open in the same frame as it was clicked."
+        },
+        "targetSrc": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the component target URI. Supports standard hyperlink behavior."
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the title of the component."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ProductSwitchItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ProgressIndicator": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Shows the progress of a process in a graphical way. To indicate the progress,\nthe inside of the component is filled with a color.\n\n### Responsive Behavior\nYou can change the size of the Progress Indicator by changing its `width` or `height` CSS properties.\n\n\n\n__Note:__ This is a UI5 Web Component! [ProgressIndicator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ProgressIndicator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.16.0](https://github.com/UI5/webcomponents/releases/tag/v1.16.0) of **@ui5/webcomponents**."
+        },
+        "displayValue": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Specifies the text value to be displayed in the bar.\n\n**Note:**\n\n- If there is no value provided or the value is empty, the default percentage value is shown.\n- If `hideValue` property is `true` both the `displayValue` and `value` property values are not shown."
+        },
+        "hideValue": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component value is shown.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Specifies the numerical value in percent for the length of the component.\n\n**Note:**\nIf a value greater than 100 is provided, the percentValue is set to 100. In other cases of invalid value, percentValue is set to its default of 0.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ProgressIndicatorDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "bar",
+          "description": "Used to style the main bar of the `ui5-progress-indicator`"
+        },
+        {
+          "name": "remaining-bar",
+          "description": "Used to style the remaining bar of the `ui5-progress-indicator`"
+        }
+      ]
+    },
+    "RadioButton": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `RadioButton` component enables users to select a single option from a set of options.\nWhen a `RadioButton` is selected by the user, the\n`change` event is fired.\nWhen a `RadioButton` that is within a group is selected, the one\nthat was previously selected gets automatically deselected. You can group radio buttons by using the `name` property.\n\n**Note:** If `RadioButton` is not part of a group, it can be selected once, but can not be deselected back.\n\n### Keyboard Handling\n\nOnce the `RadioButton` is on focus, it might be selected by pressing the Space and Enter keys.\n\nThe Arrow Down/Arrow Up and Arrow Left/Arrow Right keys can be used to change selection between next/previous radio buttons in one group,\nwhile TAB and SHIFT + TAB can be used to enter or leave the radio button group.\n\n**Note:** On entering radio button group, the focus goes to the currently selected radio button.\n\n\n\n__Note:__ This is a UI5 Web Component! [RadioButton UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/RadioButton) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<RadioButtonDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component checked state changes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.6.0](https://github.com/UI5/webcomponents/releases/tag/v1.6.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "checked": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is checked or not.\n\n**Note:** The property value can be changed with user interaction,\neither by clicking/tapping on the component,\nor by using the Space or Enter key.\n\n**Note:** Only enabled radio buttons can be checked.\nRead-only radio buttons are not selectable, and therefore are always unchecked.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\nRadio buttons with the same `name` will form a radio button group.\n\n**Note:** By this name the component will be identified upon submission in an HTML form.\n\n**Note:** The selection can be changed with `ARROW_UP/DOWN` and `ARROW_LEFT/RIGHT` keys between radio buttons in same group.\n\n**Note:** Only one radio button can be selected per group."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component isn't editable or selectable.\nHowever, because it's focusable, it still provides visual feedback upon user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the component."
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the form value of the component.\nWhen a form with a radio button group is submitted, the group's value\nwill be the value of the currently selected radio button."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | WrappingType | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines whether the component text wraps when there is not enough space.\n\n**Note:** for option \"Normal\" the text will wrap and the words will not be broken based on hyphenation.",
+          "defaultValue": {
+            "value": "\"Normal\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<RadioButtonDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "inner-ring",
+          "description": "Used to style the inner ring of the `ui5-radio-button`."
+        },
+        {
+          "name": "outer-ring",
+          "description": "Used to style the outer ring of the `ui5-radio-button`."
+        }
+      ]
+    },
+    "RangeSlider": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Represents a numerical interval and two handles (grips) to select a sub-range within it.\nThe purpose of the component to enable visual selection of sub-ranges within a given interval.\n\n### Structure\nThe most important properties of the Range Slider are:\n\n- min - The minimum value of the slider range.\n- max - The maximum value of the slider range.\n- value - The current value of the slider.\n- step - Determines the increments in which the slider will move.\n- showTooltip - Determines if a tooltip should be displayed above the handle.\n- showTickmarks - Displays a visual divider between the step values.\n- labelInterval - Labels some or all of the tickmarks with their values.\n\n#### Notes:\n\n- The right and left handle can be moved individually and their positions could therefore switch.\n- The entire range can be moved along the interval.\n\n### Usage\nThe most common use case is to select and move sub-ranges on a continuous numerical scale.\n\n### Responsive Behavior\nYou can move the currently selected range by clicking on it and dragging it along the interval.\n\n### Keyboard Handling\n\n- `Left or Down Arrow` - Moves a component's handle or the entire selection one step to the left;\n- `Right or Up Arrow` - Moves a component's handle or the entire selection one step to the right;\n- `Left or Down Arrow + Ctrl/Cmd` - Moves a component's handle to the left or the entire range with step equal to 1/10th of the entire range;\n- `Right or Up Arrow + Ctrl/Cmd` - Moves a component's handle to the right or the entire range with step equal to 1/10th of the entire range;\n- `Plus` - Same as `Right or Up Arrow`;\n- `Minus` - Same as `Left or Down Arrow`;\n- `Home` - Moves the entire selection or the selected handle to the beginning of the component's range;\n- `End` - Moves the entire selection or the selected handle to the end of the component's range;\n- `Page Up` - Same as `Right or Up Arrow + Ctrl/Cmd`;\n- `Page Down` - Same as `Left or Down Arrow + Ctrl/Cmd`;\n- `Escape` - Resets the `startValue` and `endValue` properties to the values prior the component focusing;\n\n\n\n__Note:__ This is a UI5 Web Component! [RangeSlider UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/RangeSlider) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<RangeSliderDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value changes and the user has finished interacting with the slider.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<RangeSliderDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value changes due to user interaction that is not yet finished - during mouse/touch dragging.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the slider is in disabled state.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "editableTooltip": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether input fields should be used as tooltips for the handles.\n\n**Note:** Setting this option to true will only work if showTooltip is set to true.\n**Note:** In order for the component to comply with the accessibility standard, it is recommended to set the editableTooltip property to true.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "endValue": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines end point of a selection - position of a second handle on the slider.",
+          "defaultValue": {
+            "value": "100"
+          }
+        },
+        "labelInterval": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Displays a label with a value on every N-th step.\n\n**Note:** The step and tickmarks properties must be enabled.\nExample - if the step value is set to 2 and the label interval is also specified to 2 - then every second\ntickmark will be labelled, which means every 4th value number.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "max": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the maximum value of the slider.",
+          "defaultValue": {
+            "value": "100"
+          }
+        },
+        "min": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the minimum value of the slider.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
+        },
+        "showTickmarks": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Enables tickmarks visualization for each step.\n\n**Note:** The step must be a positive number.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showTooltip": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Enables handle tooltip displaying the current value.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "startValue": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines start point of a selection - position of a first handle on the slider.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "step": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the size of the slider's selection intervals (e.g. min = 0, max = 10, step = 5 would result in possible selection of the values 0, 5, 10).\n\n**Note:** If set to 0 the slider handle movement is disabled. When negative number or value other than a number, the component fallbacks to its default value.",
+          "defaultValue": {
+            "value": "1"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<RangeSliderDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "handle",
+          "description": "Used to style the handles of the `ui5-range-slider`."
+        },
+        {
+          "name": "progress-bar",
+          "description": "Used to style the progress bar, which shows the progress of the `ui5-range-slider`."
+        },
+        {
+          "name": "progress-container",
+          "description": "Used to style the progress container, the horizontal bar that visually represents the range between the minimum and maximum values, of the `ui5-range-slider`."
+        }
+      ]
+    },
+    "RatingIndicator": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The Rating Indicator is used to display a specific number of icons that are used to rate an item.\nAdditionally, it is also used to display the average and overall ratings.\n\n### Usage\nThe recommended number of icons is between 5 and 7.\n\n### Responsive Behavior\nYou can change the size of the Rating Indicator by changing its `font-size` CSS property.\n\nExample: `<RatingIndicator style=\"font-size: 3rem;\"></RatingIndicator>`\n\n### Keyboard Handling\nWhen the `RatingIndicator` is focused, the user can change the rating\nwith the following keyboard shortcuts:\n\n- [RIGHT/UP] - Increases the value of the rating by one step. If the highest value is reached, does nothing\n- [LEFT/DOWN] - Decreases the value of the rating by one step. If the lowest value is reached, does nothing.\n- [Home] - Sets the lowest value.\n- [End] - Sets the highest value.\n- [SPACE/ENTER/RETURN] - Increases the value of the rating by one step. If the highest value is reached, sets the rating to the lowest value.\n- Any number - Changes value to the corresponding number. If typed number is larger than the number of values, sets the highest value.\n\n\n\n__Note:__ This is a UI5 Web Component! [RatingIndicator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/RatingIndicator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<RatingIndicatorDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "The event is fired when the value changes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "max": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The number of displayed rating symbols.",
+          "defaultValue": {
+            "value": "5"
+          }
+        },
+        "ratedIcon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed for the selected (filled) rating symbol.\n\n**Note:** Available since [v2.20](https://github.com/UI5/webcomponents/releases/tag/v2.20) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"favorite\""
+          }
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "size": {
+          "type": {
+            "name": "enum",
+            "raw": "RatingIndicatorSize | \"S\" | \"M\" | \"L\"",
+            "value": [
+              {
+                "value": "\"S\"",
+                "description": "Small size for compact layouts."
+              },
+              {
+                "value": "\"M\"",
+                "description": "Medium size, used as the default option.\nOffers a balanced appearance for most scenarios."
+              },
+              {
+                "value": "\"L\"",
+                "description": "Large size for prominent or spacious layouts."
+              },
+              {
+                "value": "\"S\""
+              },
+              {
+                "value": "\"M\""
+              },
+              {
+                "value": "\"L\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the size of the component.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"M\""
+          }
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents**."
+        },
+        "unratedIcon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed for the unselected (empty) rating symbol.\n\n**Note:** Available since [v2.20](https://github.com/UI5/webcomponents/releases/tag/v2.20) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"unfavorite\""
+          }
+        },
+        "value": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The indicated value of the rating.\n\n**Note:** If you set a number which is not round, it would be shown as follows:\n\n- 1.0 - 1.2 -> 1\n- 1.3 - 1.7 -> 1.5\n- 1.8 - 1.9 -> 2",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<RatingIndicatorDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ResponsivePopover": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ResponsivePopover` acts as a Popover on desktop and tablet, while on phone it acts as a Dialog.\nThe component improves tremendously the user experience on mobile.\n\n### Usage\nUse it when you want to make sure that all the content is visible on any device.\n\n\n\n__Note:__ This is a UI5 Web Component! [ResponsivePopover UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ResponsivePopover) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the Popup.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "footer": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the footer HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onBeforeClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, PopupBeforeCloseEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "escPressed",
+                "type": "boolean",
+                "description": "Indicates that `ESC` key has triggered the event."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onBeforeOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "PopupAccessibleRole | \"None\" | \"Dialog\" | \"AlertDialog\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "Represents no ARIA role."
+              },
+              {
+                "value": "\"Dialog\"",
+                "description": "Represents the ARIA role \"dialog\"."
+              },
+              {
+                "value": "\"AlertDialog\"",
+                "description": "Represents the ARIA role \"alertdialog\"."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Dialog\""
+              },
+              {
+                "value": "\"AlertDialog\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Dialog\""
+          }
+        },
+        "allowTargetOverlap": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines if there is no enough space, the component can be placed\nover the target.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text.\n\n**Note:** If `header` slot is provided, the `headerText` is ignored."
+        },
+        "hideArrow": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component arrow is hidden.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "horizontalAlign": {
+          "type": {
+            "name": "enum",
+            "raw": "PopoverHorizontalAlign | \"Center\" | \"Start\" | \"End\" | \"Stretch\"",
+            "value": [
+              {
+                "value": "\"Center\"",
+                "description": "Popover is centered."
+              },
+              {
+                "value": "\"Start\"",
+                "description": "Popover is aligned with the start of the target."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Popover is aligned with the end of the target."
+              },
+              {
+                "value": "\"Stretch\"",
+                "description": "Popover is stretched."
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Stretch\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the horizontal alignment of the component.",
+          "defaultValue": {
+            "value": "\"Center\""
+          }
+        },
+        "initialFocus": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the ID of the HTML Element, which will get the initial focus.\n\n**Note:** If an element with `autofocus` attribute is added inside the component,\n`initialFocus` won't take effect."
+        },
+        "modal": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should close when\nclicking/tapping outside the popover.\nIf enabled, it blocks any interaction with the background.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if the element is open\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "opener": {
+          "type": {
+            "name": "string | HTMLElement"
+          },
+          "required": false,
+          "description": "Defines the ID or DOM Reference of the element at which the popover is shown.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
+        },
+        "placement": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Start\" | \"End\" | PopoverPlacement | \"Top\" | \"Bottom\"",
+            "value": [
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Start\"",
+                "description": "Popover will be placed at the start of the reference element."
+              },
+              {
+                "value": "\"End\"",
+                "description": "Popover will be placed at the end of the reference element."
+              },
+              {
+                "value": "\"Top\"",
+                "description": "Popover will be placed at the top of the reference element."
+              },
+              {
+                "value": "\"Bottom\"",
+                "description": "Popover will be placed at the bottom of the reference element."
+              },
+              {
+                "value": "\"Top\""
+              },
+              {
+                "value": "\"Bottom\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines on which side the component is placed at.",
+          "defaultValue": {
+            "value": "\"End\""
+          }
+        },
+        "preventFocusRestore": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "preventInitialFocus": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "resizable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is resizable.\n**Note:** This property is effective only on desktop devices.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "verticalAlign": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Center\" | \"Stretch\" | \"Top\" | \"Bottom\" | PopoverVerticalAlign",
+            "value": [
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Stretch\""
+              },
+              {
+                "value": "\"Top\""
+              },
+              {
+                "value": "\"Bottom\""
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Top\"",
+                "description": "Popover will be placed at the top of the reference control."
+              },
+              {
+                "value": "\"Bottom\"",
+                "description": "Popover will be placed at the bottom of the reference control."
+              },
+              {
+                "value": "\"Stretch\"",
+                "description": "Popover will be streched"
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the vertical alignment of the component.",
+          "defaultValue": {
+            "value": "\"Center\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ResponsivePopoverDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "applyFocus",
+          "description": "Focuses the element denoted by `initialFocus`, if provided, or the first focusable element otherwise.",
+          "params": [],
+          "returns": {
+            "type": "Promise<void>"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "content",
+          "description": "Used to style the content of the component"
+        },
+        {
+          "name": "footer",
+          "description": "Used to style the footer of the component"
+        },
+        {
+          "name": "header",
+          "description": "Used to style the header of the component"
+        }
+      ]
+    },
+    "Search": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A `Search` is an input with suggestions, used for user search.\n\nThe `Search` consists of several elements parts:\n- Scope - displays a select in the beggining of the component, used for filtering results by their scope.\n- Input field - for user input value\n- Clear button - gives the possibility for deleting the entered value\n- Search button - a primary button for performing search, when the user has entered a search term\n- Suggestions - a list with available search suggestions\n\n\n\n__Note:__ This is a UI5 Web Component! [Search UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/Search) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "action": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the popup footer action button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"action\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<Button>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the Search suggestion items.\n\n__Supported Node Type/s:__ `Array<SearchItem | SearchItemGroup>`"
+        },
+        "filterButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the filter button slot, used to display an additional filtering button.\nThis slot is intended for passing a `ui5-button` with a filter icon to provide extended filtering options.\n\n**Note:** Scope button and Filter button are mutually exclusive.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"filterButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<Button>`"
+        },
+        "illustration": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the illustrated message to be shown in the popup.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"illustration\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IllustratedMessage>`"
+        },
+        "messageArea": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the illustrated message to be shown in the popup.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"messageArea\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<SearchMessageArea>`"
+        },
+        "scopes": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the component scope options.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"scopes\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ISearchScope>`"
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SearchDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the popup is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SearchDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when typing in input or clear icon is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SearchDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the popup is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onScopeChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SearchDomRef, SearchFieldScopeSelectionChangeDetails>) => void"
+          },
+          "required": false,
+          "description": "Fired when the scope has changed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "scope",
+                "type": "HTMLElement",
+                "description": "The newly selected scope"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSearch": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SearchDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user has triggered search with Enter key or Search Button press.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA description of the field."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "fieldLoading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether a loading indicator should be shown in the input field.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether a loading indicator should be shown in the popup.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "noTypeahead": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the value will be autcompleted to match an item.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the items picker is open.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
+        },
+        "scopeValue": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component:\n\nApplications are responsible for setting the correct scope value.\n\n**Note:** If the given value does not match any existing scopes,\nno scope will be selected and the SearchField scope component will be displayed as empty.\n\n**Note:** Available since [v2.18.0](https://github.com/UI5/webcomponents/releases/tag/v2.18.0) of **@ui5/webcomponents-fiori**."
+        },
+        "showClearIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the clear icon of the search will be shown.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SearchDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SearchItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A `SearchItem` is a list item, used for displaying search suggestions\n\n\n\n__Note:__ This is a UI5 Web Component! [SearchItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SearchItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "actions": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the actionable elements.\nThis slot allows placing additional interactive elements (such as buttons, icons, or tags)\nnext to the delete button, providing flexible customization for various user actions.\n\n**Note:** While the slot is flexible, for consistency with design guidelines,\nit's recommended to use `ui5-button` with `Transparent` design or `ui5-icon` elements.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"actions\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "image": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "**Note:** While the slot allows the option of setting a custom avatar, to comply with the\ndesign guidelines, use the `ui5-avatar` with size - XS.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"image\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onDelete": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SearchItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when delete button is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "deletable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the search item is deletable.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "description": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the description that appears right under the item text, if available.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents-fiori**."
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon name of the search item.\n**Note:** If provided, the image slot will be ignored."
+        },
+        "scopeName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the scope of the search item"
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the search item is selected.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the heading text of the search item."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SearchItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SearchItemGroup": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `SearchItemGroup` is type of suggestion item,\nthat can be used to split the `SearchItem` suggestions into groups.\n\n__Note:__ This is a UI5 Web Component! [SearchItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SearchItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the <code>ui5-li-group</code>.\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
+        },
+        "onMove": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SearchItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMoveOver": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SearchItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "headerAccessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the header."
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text of the <code>ui5-li-group</code>."
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "WrappingType | \"None\" | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ui5-expandable-text` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SearchItemGroupDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "header",
+          "description": "Used to style the header item of the group"
+        },
+        {
+          "name": "title",
+          "description": "Used to style the title of the group header"
+        }
+      ]
+    },
+    "SearchItemShowMore": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A `SearchItemShowMore` is a special type of ui5-li that acts as a button to progressively reveal additional (overflow) items within a group.\n\n\n\n__Note:__ This is a UI5 Web Component! [SearchItemShowMore UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SearchItemShowMore) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SearchItemShowMoreDomRef, ShowMoreItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is activated, either with a mouse/tap\nor by pressing the Enter or Space keys.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "fromKeyboard",
+                "type": "boolean",
+                "description": "Indicates whether the event was fired\ndue to keyboard interaction (Enter or Space) rather than mouse/tap."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "itemsToShowCount": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Specifies the number of additional items available to show.\nIf no value is defined, the control shows \"Show more\" (without any counter).\nIf a number is provided, it displays \"Show more (N)\", where N is that number."
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the show more item is selected.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SearchItemShowMoreDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SearchMessageArea": {
+      "package": "@ui5/webcomponents-react",
+      "description": "`import \"@ui5/webcomponents-fiori/dist/SearchMessageArea.js\";`\n\n__Note:__ This is a UI5 Web Component! [SearchMessageArea UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SearchMessageArea) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "description": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the description text to be displayed."
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text to be displayed."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SearchMessageAreaDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SearchScope": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `SearchScope` represents the options for the scope in `Search`.\n\n__Note:__ This is a UI5 Web Component! [SearchScope UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SearchScope) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the component."
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the `SearchScope`.\nUsed for selection in Search scopes."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SearchScopeDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SegmentedButton": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `SegmentedButton` shows a group of items. When the user clicks or taps\none of the items, it stays in a pressed state. It automatically resizes the items\nto fit proportionally within the component. When no width is set, the component uses the available width.\n\n\n\n\n__Note:__ This is a UI5 Web Component! [SegmentedButton UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SegmentedButton) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of `SegmentedButton`.\n\n**Note:** Multiple items are allowed.\n\n**Note:** Use the `SegmentedButtonItem` for the intended design.\n\n__Supported Node Type/s:__ `Array<ISegmentedButtonItem>`"
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SegmentedButtonDomRef, SegmentedButtonSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the selected item changes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "selectedItems",
+                "type": "Array<ISegmentedButtonItem>",
+                "description": "an array of selected items. Since: 1.14.0"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the HTML Elements that describe the component.\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.0.3](https://github.com/UI5/webcomponents/releases/tag/v1.0.3) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the HTML Elements that label the component.\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
+        },
+        "itemsFitContent": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the segmented button items should be sized to fit their content.\n\nIf set to `true`, each item will be sized to fit its content, with any extra space distributed after the last item.\nIf set to `false` (the default), all items will be equally sized to fill the available space.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selectionMode": {
+          "type": {
+            "name": "enum",
+            "raw": "SegmentedButtonSelectionMode | \"Single\" | \"Multiple\"",
+            "value": [
+              {
+                "value": "\"Single\"",
+                "description": "There is always one selected. Selecting one deselects the previous one."
+              },
+              {
+                "value": "\"Multiple\"",
+                "description": "Multiple items can be selected at a time. All items can be deselected."
+              },
+              {
+                "value": "\"Single\""
+              },
+              {
+                "value": "\"Multiple\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component selection mode.\n\n**Note:** Available since [v1.14.0](https://github.com/UI5/webcomponents/releases/tag/v1.14.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Single\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SegmentedButtonDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SegmentedButtonItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Users can use the `SegmentedButtonItem` as part of a `SegmentedButton`.\n\nClicking or tapping on a `SegmentedButtonItem` changes its state to `selected`.\nThe item returns to its initial state when the user clicks or taps on it again.\nBy applying additional custom CSS-styling classes, apps can give a different style to any\n`SegmentedButtonItem`.\n\n\n\n__Note:__ This is a UI5 Web Component! [SegmentedButtonItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SegmentedButtonItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the HTML Elements that describe the component.\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\nA disabled component can't be selected or\nfocused, and it is not in the tab chain.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon, displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is displayed as selected.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\n**Note:** A tooltip attribute should be provided for icon-only buttons, in order to represent their exact meaning/function.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SegmentedButtonItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Select": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Select` component is used to create a drop-down list.\n\n### Usage\n\nThere are two main usages of the `ui5-select>`.\n\n- With Option (`Option`) web component:\n\nThe available options of the Select are defined by using the Option component.\nThe Option comes with predefined design and layout, including `icon`, `text` and `additional-text`.\n\n- With OptionCustom (`OptionCustom`) web component.\n\nOptions with custom content are defined by using the OptionCustom component.\nThe OptionCustom component comes with no predefined layout and it expects consumers to define it.\n\n### Selection\n\nThe options can be selected via user interaction (click or with the use of the Space and Enter keys)\nand programmatically - the Select component supports two distinct selection APIs, though mixing them is not supported:\n- The \"value\" property of the Select component\n- The \"selected\" property on individual options\n\n**Note:** If the \"value\" property is set but does not match any option,\nno option will be selected and the Select component will be displayed as empty.\n\n**Note:** when both \"value\" and \"selected\" are both used (although discouraged),\nthe \"value\" property will take precedence.\n\n### Keyboard Handling\n\nThe `Select` provides advanced keyboard handling.\n\n- [F4] / [Alt] + [Up] / [Alt] + [Down] / [Space] or [Enter] - Opens/closes the drop-down.\n- [Up] or [Down] - If the drop-down is closed - changes selection to the next or the previous option. If the drop-down is opened - moves focus to the next or the previous option.\n- [Space], [Enter] - If the drop-down is opened - selects the focused option.\n- [Escape] - Closes the drop-down without changing the selection.\n- [Home] - Navigates to first option\n- [End] - Navigates to the last option\n\n\n\n`import \"@ui5/webcomponents/dist/Option\";`\n`import \"@ui5/webcomponents/dist/OptionCustom\";`\n\n__Note:__ This is a UI5 Web Component! [Select UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Select) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the component options.\n\n**Note:** Only one selected option is allowed.\nIf more than one option is defined as selected, the last one would be considered as the selected one.\n\n**Note:** Use the `Option` component to define the desired options.\n\n__Supported Node Type/s:__ `Array<IOption>`"
+        },
+        "label": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the HTML element that will be displayed in the component input part,\nrepresenting the selected option.\n\n**Note:** If not specified and `OptionCustom` is used,\neither the option's `display-text` or its textContent will be displayed.\n\n**Note:** If not specified and `Option` is used,\nthe option's textContent will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"label\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.17.0](https://github.com/UI5/webcomponents/releases/tag/v1.17.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n**Note:** If the component has `suggestionItems`,\nthe `valueStateMessage` would be displayed as part of the same popover, if used on desktop, or dialog - on phone.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SelectDomRef, SelectChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the selected option changes.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "selectedOption",
+                "type": "IOption",
+                "description": "the selected option."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SelectDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component's dropdown menu closes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onLiveChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SelectDomRef, SelectLiveChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user navigates through the options, but the selection is not finalized,\nor when pressing the ESC key to revert the current selection.\n\n**Note:** Available since [v1.17.0](https://github.com/UI5/webcomponents/releases/tag/v1.17.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "selectedOption",
+                "type": "IOption",
+                "description": "the selected option."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SelectDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component's dropdown menu opens.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the select.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the select."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.\n\n**Note:** Available since [v1.21.0](https://github.com/UI5/webcomponents/releases/tag/v1.21.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "textSeparator": {
+          "type": {
+            "name": "enum",
+            "raw": "SelectTextSeparator | \"Bullet\" | \"Dash\" | \"VerticalLine\"",
+            "value": [
+              {
+                "value": "\"Bullet\"",
+                "description": "Will show bullet(·) as separator on two columns layout when Select is in read-only mode."
+              },
+              {
+                "value": "\"Dash\"",
+                "description": "Will show N-dash(–) as separator on two columns layout when Select is in read-only mode."
+              },
+              {
+                "value": "\"VerticalLine\"",
+                "description": "Will show vertical line(|) as separator on two columns layout when Select is in read-only mode."
+              },
+              {
+                "value": "\"Bullet\""
+              },
+              {
+                "value": "\"Dash\""
+              },
+              {
+                "value": "\"VerticalLine\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the separator type for the two columns layout when Select is in read-only mode.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Dash\""
+          }
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the select.\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**."
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component:\n\n- when get - returns the value of the component or the value/text content of the selected option.\n- when set - selects the option with matching `value` property or text content.\n\n**Note:** Use either the Select's value or the Options' selected property.\nMixed usage could result in unexpected behavior.\n\n**Note:** If the given value does not match any existing option,\nno option will be selected and the Select component will be displayed as empty.\n\n**Note:** Available since [v1.20.0](https://github.com/UI5/webcomponents/releases/tag/v1.20.0) of **@ui5/webcomponents**."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SelectDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "popover",
+          "description": "Used to style the popover element"
+        }
+      ]
+    },
+    "ShellBar": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ShellBar` is meant to serve as an application header\nand includes numerous built-in features, such as: logo, profile image/icon, title, search field, notifications and so on.\n\n### Stable DOM Refs\n\nYou can use the following stable DOM refs for the `ShellBar`:\n\n- logo\n- notifications\n- overflow\n- profile\n- product-switch\n\n### Keyboard Handling\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [ShellBar UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ShellBar) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "assistant": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the assistant slot.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"assistant\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "branding": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the branding slot.\nThe `ShellBarBranding` component is intended to be placed inside this slot.\nContent placed here takes precedence over the `primaryTitle` property and the `logo` content slot.\n\n**Note:** The `branding` slot is in an experimental state and is a subject to change.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"branding\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<ShellBarBranding>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the `ShellBar` additional items.\n\n**Note:**\nYou can use the `<ShellBarItem></ShellBarItem>`.\n\n__Supported Node Type/s:__ `Array<ShellBarItem>`"
+        },
+        "content": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Define the items displayed in the content area.\n\nUse the `data-hide-order` attribute with numeric value to specify the order of the items to be hidden when the space is not enough.\nLower values will be hidden first.\n\n**Note:** The `content` slot is in an experimental state and is a subject to change.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"content\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "logo": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the logo of the `ShellBar`.\nFor example, you can use `ui5-avatar` or `img` elements as logo.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"logo\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "menuItems": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the items displayed in menu after a click on a start button.\n\n**Note:** You can use the  `<ui5-li></ui5-li>` and its ancestors.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"menuItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
+        },
+        "profile": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "You can pass `ui5-avatar` to set the profile image/icon.\nIf no profile slot is set - profile will be excluded from actions.\n\n**Note:** We recommend not using the `size` attribute of `ui5-avatar` because\nit should have specific size by design in the context of `ShellBar` profile.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"profile\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "searchField": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the `ui5-input`, that will be used as a search field.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"searchField\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IShellBarSearchField>`"
+        },
+        "startButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines a `ui5-button` in the bar that will be placed in the beginning.\nWe encourage this slot to be used for a menu button.\nIt gets overstyled to match ShellBar's styling.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"startButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "onContentItemVisibilityChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarContentItemVisibilityChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired, when an item from the content slot is hidden or shown.\n**Note:** The `content-item-visibility-change` event is in an experimental state and is a subject to change.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "array",
+                "type": "Array<HTMLElement>",
+                "description": "of all the items that are hidden"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onLogoClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarLogoClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired, when the logo is activated.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "targetRef",
+                "type": "HTMLElement",
+                "description": "dom ref of the activated element"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMenuItemClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarMenuItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired, when a menu item is activated\n\n**Note:** You can prevent closing of overflow popover by calling `event.preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "DOM ref of the activated list item"
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onNotificationsClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarNotificationsClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired, when the notification icon is activated.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "targetRef",
+                "type": "HTMLElement",
+                "description": "dom ref of the activated element"
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onProductSwitchClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarProductSwitchClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired, when the product switch icon is activated.\n\n**Note:** You can prevent closing of overflow popover by calling `event.preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "targetRef",
+                "type": "HTMLElement",
+                "description": "dom ref of the activated element"
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onProfileClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarProfileClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired, when the profile slot is present.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "targetRef",
+                "type": "HTMLElement",
+                "description": "dom ref of the activated element"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSearchButtonClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarSearchButtonEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired, when the search button is activated.\n\n**Note:** You can prevent expanding/collapsing of the search field by calling `event.preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "searchFieldVisible",
+                "type": "Boolean",
+                "description": "whether the search field is visible"
+              },
+              {
+                "name": "targetRef",
+                "type": "HTMLElement",
+                "description": "dom ref of the activated element"
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onSearchFieldClear": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarSearchFieldClearEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired, when the search cancel button is activated.\n\n**Note:** You can prevent the default behavior (clearing the search field value) by calling `event.preventDefault()`. The search will still be closed.\n**Note:** The `search-field-clear` event is in an experimental state and is a subject to change.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "targetRef",
+                "type": "HTMLElement",
+                "description": "dom ref of the cancel button element"
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onSearchFieldToggle": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarSearchFieldToggleEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired, when the search field is expanded or collapsed.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "expanded",
+                "type": "Boolean",
+                "description": "whether the search field is expanded"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ShellBarAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines additional accessibility attributes on different areas of the component.\n\nThe accessibilityAttributes object has the following fields,\nwhere each field is an object supporting one or more accessibility attributes:\n\n- **logo** - `logo.role` and `logo.name`.\n- **notifications** - `notifications.expanded` and `notifications.hasPopup`.\n- **profile** - `profile.expanded`, `profile.hasPopup` and `profile.name`.\n- **product** - `product.expanded` and `product.hasPopup`.\n- **search** - `search.hasPopup`.\n- **overflow** - `overflow.expanded` and `overflow.hasPopup`.\n- **branding** - `branding.name`.\n\nThe accessibility attributes support the following values:\n\n- **role**: Defines the accessible ARIA role of the logo area.\nAccepts the following string values: `button` or `link`.\n\n- **expanded**: Indicates whether the button, or another grouping element it controls,\nis currently expanded or collapsed.\nAccepts the following string values: `true` or `false`.\n\n- **hasPopup**: Indicates the availability and type of interactive popup element,\nsuch as menu or dialog, that can be triggered by the button.\n\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n- **name**: Defines the accessible ARIA name of the area.\nAccepts any string.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "disableSearchCollapse": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Disables the automatic search field expansion/collapse when the available space is not enough.\n\n**Note:** The `disableSearchCollapse` property is in an experimental state and is a subject to change.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideSearchButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the visibility state of the search button.\n\n**Note:** The `hideSearchButton` property is in an experimental state and is a subject to change.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "notificationsCount": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `notificationsCount`,\ndisplayed in the notification icon top-right corner."
+        },
+        "primaryTitle": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `primaryTitle`.\n\n**Note:** The `primaryTitle` would be hidden on S screen size (less than approx. 700px)."
+        },
+        "secondaryTitle": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `secondaryTitle`.\n\n**Note:** The `secondaryTitle` would be hidden on S and M screen sizes (less than approx. 1300px)."
+        },
+        "showNotifications": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines, if the notification icon would be displayed.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showProductSwitch": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines, if the product switch icon would be displayed.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showSearchField": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines, if the Search Field would be displayed when there is a valid `searchField` slot.\n\n**Note:** By default the Search Field is not displayed.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ShellBarDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "closeOverflow",
+          "description": "Closes the overflow popover.",
+          "params": [],
+          "returns": {
+            "type": "void"
+          }
+        },
+        {
+          "name": "getSearchButtonDomRef",
+          "description": "Returns the search button DOM reference.",
+          "params": [],
+          "returns": {
+            "type": "Promise<HTMLElement | null>"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "root",
+          "description": "Used to style the outermost wrapper of the `ui5-shellbar`"
+        }
+      ]
+    },
+    "ShellBarBranding": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ShellBarBranding` component is intended to be placed inside the branding slot of the\n`ShellBar` component. Its content has higher priority than the `primaryTitle` property\nand the `logo` slot of `ShellBar`.\n\n__Note:__ This is a UI5 Web Component! [ShellBarBranding UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ShellBarBranding) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the title for the ui5-shellbar-branding component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "logo": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the logo of the `ShellBar`.\nFor example, you can use `ui5-avatar` or `img` elements as logo.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"logo\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarBrandingDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired, when the logo is activated.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text alternative of the component.\nIf not provided a default text alternative will be set, if present."
+        },
+        "href": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the component href.\n\n**Note:** Standard hyperlink behavior is supported."
+        },
+        "target": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the component target.\n\n**Notes:**\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `_search`\n\n**This property must only be used when the `href` property is set.**"
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ShellBarBrandingDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ShellBarItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ShellBarItem` represents a custom item for `ShellBar`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ShellBarItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ShellBarItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarItemDomRef, ShellBarItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the item is clicked.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "targetRef",
+                "type": "HTMLElement",
+                "description": "DOM ref of the clicked element"
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ShellBarItemAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines additional accessibility attributes on Shellbar Items.\n\nThe accessibility attributes support the following values:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls,\nis currently expanded or collapsed.\nAccepts the following string values: `true` or `false`.\n\n- **hasPopup**: Indicates the availability and type of interactive popup element,\nsuch as menu or dialog, that can be triggered by the button.\n\n- **controls**: Identifies the element (or elements) whose contents\nor presence are controlled by the component.\nAccepts a lowercase string value, referencing the ID of the element it controls.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "count": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the count displayed in badge."
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the item's icon."
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the item text.\n\n**Note:** The text is only displayed inside the overflow popover list view."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ShellBarItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ShellBarSearch": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Search field for the ShellBar component.\n\n__Note:__ This is a UI5 Web Component! [ShellBarSearch UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ShellBarSearch) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "action": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the popup footer action button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"action\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<Button>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the Search suggestion items.\n\n__Supported Node Type/s:__ `Array<SearchItem | SearchItemGroup>`"
+        },
+        "filterButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the filter button slot, used to display an additional filtering button.\nThis slot is intended for passing a `ui5-button` with a filter icon to provide extended filtering options.\n\n**Note:** Scope button and Filter button are mutually exclusive.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"filterButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<Button>`"
+        },
+        "illustration": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the illustrated message to be shown in the popup.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"illustration\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IllustratedMessage>`"
+        },
+        "messageArea": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the illustrated message to be shown in the popup.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"messageArea\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<SearchMessageArea>`"
+        },
+        "scopes": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the component scope options.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"scopes\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ISearchScope>`"
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarSearchDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the popup is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarSearchDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when typing in input or clear icon is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarSearchDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the popup is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onScopeChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarSearchDomRef, SearchFieldScopeSelectionChangeDetails>) => void"
+          },
+          "required": false,
+          "description": "Fired when the scope has changed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "scope",
+                "type": "HTMLElement",
+                "description": "The newly selected scope"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSearch": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ShellBarSearchDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user has triggered search with Enter key or Search Button press.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA description of the field."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "autoOpen": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the suggestions popover should be opened on focus.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "fieldLoading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether a loading indicator should be shown in the input field.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether a loading indicator should be shown in the popup.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "noTypeahead": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the value will be autcompleted to match an item.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the items picker is open.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
+        },
+        "scopeValue": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component:\n\nApplications are responsible for setting the correct scope value.\n\n**Note:** If the given value does not match any existing scopes,\nno scope will be selected and the SearchField scope component will be displayed as empty.\n\n**Note:** Available since [v2.18.0](https://github.com/UI5/webcomponents/releases/tag/v2.18.0) of **@ui5/webcomponents-fiori**."
+        },
+        "showClearIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the clear icon of the search will be shown.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ShellBarSearchDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ShellBarSpacer": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ShellBarSpacer` is an element, used for visual separation between the two content parts of the `ShellBar`.\n**Note:** The `ShellBarSpacer` component is in an experimental state and is a subject to change.\n\n__Note:__ This is a UI5 Web Component! [ShellBarSpacer UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ShellBarSpacer) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ShellBarSpacerDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SideNavigation": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `SideNavigation` is used as a standard menu in applications.\nIt consists of three containers: header (top-aligned), main navigation section (top-aligned) and the secondary section (bottom-aligned).\n\n - The header is meant for displaying user related information - profile data, avatar, etc.\n - The main navigation section is related to the user's current work context.\n - The secondary section is mostly used to link additional information that may be of interest (legal information, developer communities, external help, contact information and so on).\n\n### Usage\n\nUse the available `SideNavigationGroup`, `SideNavigationItem`\nand `SideNavigationSubItem` components to build your menu.\nThe items can consist of text only or an icon with text. The use or non-use of icons must be consistent for all items on one level.\nYou must not combine entries with and without icons on the same level. We strongly recommend that you do not use icons on the second level.\n\nThe `SideNavigation` component is designed to be used within a `NavigationLayout` component to ensure an optimal user experience.\n\nUsing it standalone may not match the intended design and functionality.\nFor example, the side navigation may not exhibit the correct behavior on smaller screens.\nAdditionally, the padding of the `ShellBar` will not match the padding of the side navigation.\n\n### Keyboard Handling\n\n### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n\n`import \"@ui5/webcomponents-fiori/dist/SideNavigationGroup.js\";` (for `SideNavigationGroup`)\n\n`import \"@ui5/webcomponents-fiori/dist/SideNavigationItem.js\";` (for `SideNavigationItem`)\n\n`import \"@ui5/webcomponents-fiori/dist/SideNavigationSubItem.js\";` (for `SideNavigationSubItem`)\n\n__Note:__ This is a UI5 Web Component! [SideNavigation UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SideNavigation) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the main items of the component.\n\n__Supported Node Type/s:__ `Array<SideNavigationItemBase>`"
+        },
+        "fixedItems": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the fixed items at the bottom of the component.\n\n**Note:** In order to achieve the best user experience, it is recommended that you keep the fixed items \"flat\" (do not pass sub-items)\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"fixedItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<SideNavigationItemBase>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header of the `SideNavigation`.\n\n**Note:** The header is displayed when the component is expanded - the property `collapsed` is false;\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onItemClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SideNavigationDomRef, SideNavigationItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when an item is clicked.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "SideNavigationSelectableItemBase",
+                "description": "The clicked item."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SideNavigationDomRef, SideNavigationSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the selection has changed via user interaction.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "SideNavigationSelectableItemBase",
+                "description": "The selected item."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents-fiori**."
+        },
+        "collapsed": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the `SideNavigation` is expanded or collapsed.\n\n**Note:** On small screens (screen width of 599px or less) the collapsed mode is not supported, and in\nexpanded mode the side navigation will take the whole width of the screen.\nThe `SideNavigation` component is intended to be used within a `NavigationLayout`\ncomponent to ensure proper responsive behavior. If you choose not to use the\n`NavigationLayout`, you will need to implement the appropriate responsive patterns yourself,\nparticularly for smaller screens where the collapsed mode should not be used.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SideNavigationDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SideNavigationGroup": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Represents a group of navigation actions within `SideNavigation`.\nThe `SideNavigationGroup` can only be used inside a `SideNavigation`.\n\n\n\n__Note:__ This is a UI5 Web Component! [SideNavigationGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SideNavigationGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines nested items by passing `SideNavigationItem` to the default slot.\n\n__Supported Node Type/s:__ `Array<SideNavigationItem>`"
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "expanded": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the item is expanded",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the item."
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\nA tooltip attribute should be provided, in order to represent meaning/function,\nwhen the component is collapsed (\"icon only\" design is visualized) or the item text is truncated.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SideNavigationGroupDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SideNavigationItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Represents a navigation action. It can provide sub items.\nThe `SideNavigationItem` is used within `SideNavigation` or `SideNavigationGroup` only.\n\n\n\n__Note:__ This is a UI5 Web Component! [SideNavigationItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SideNavigationItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines nested items by passing `SideNavigationSubItem` to the default slot.\n\n__Supported Node Type/s:__ `Array<SideNavigationSubItem>`"
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SideNavigationItemDomRef, SideNavigationItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is activated either with a click/tap or by using the [Enter] or [Space] keys.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "altKey",
+                "type": "boolean",
+                "description": "Returns whether the \"ALT\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "ctrlKey",
+                "type": "boolean",
+                "description": "Returns whether the \"CTRL\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "metaKey",
+                "type": "boolean",
+                "description": "Returns whether the \"META\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "shiftKey",
+                "type": "boolean",
+                "description": "Returns whether the \"SHIFT\" key was pressed when the event was triggered."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "SideNavigationItemAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n**Note:** Do not use it on parent items, as it will be overridden if the item is in the overflow menu.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "SideNavigationItemDesign | \"Default\" | \"Action\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "Design for items that perform navigation, contain navigation child items, or both."
+              },
+              {
+                "value": "\"Action\"",
+                "description": "Design for items that trigger an action, such as opening a dialog.\n\n**Note:** Items with this design must not have sub-items.\n\n**Note:** Items that open a dialog must set `hasPopup=\"dialog\"` via `accessibilityAttributes` property."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Action\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Item design.\n\n**Note:** Items with \"Action\" design must not have sub-items.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "expanded": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the item is expanded",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "href": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the link target URI. Supports standard hyperlink behavior.\nIf a JavaScript action should be triggered,\nthis should not be set, but instead an event handler\nfor the `click` event should be registered.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**."
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon of the item.\n\n**Note:** Icons on second-level (child) navigation items are not recommended according to the design specification.\n\nThe SAP-icons font provides numerous options.\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the item is selected.\n\n**Note:** Items that have a set `href` and `target` set to `_blank` should not be selectable.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "target": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the component target.\n\nPossible values:\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `framename`\n\n**Note:** Items that have a defined `href` and `target`\nattribute set to `_blank` should not be selectable.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**."
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the item."
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\nA tooltip attribute should be provided, in order to represent meaning/function,\nwhen the component is collapsed (\"icon only\" design is visualized) or the item text is truncated.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**."
+        },
+        "unselectable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the navigation item is selectable. By default, all items are selectable unless specifically marked as unselectable.\n\nWhen a parent item is marked as unselectable, selecting it will only expand or collapse its sub-items.\nTo improve user experience do not mix unselectable parent items with selectable parent items in a single side navigation.\n\n\n**Guidelines**:\n- Items with an assigned `href` and a target of `_blank` should be marked as unselectable.\n- Items that trigger actions (with design \"Action\") should be marked as unselectable.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SideNavigationItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SideNavigationSubItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Represents a single navigation action within `SideNavigationItem`.\nThe `SideNavigationSubItem` is intended to be used inside a `SideNavigationItem` only.\n\n\n\n__Note:__ This is a UI5 Web Component! [SideNavigationSubItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SideNavigationSubItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SideNavigationSubItemDomRef, SideNavigationItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is activated either with a click/tap or by using the [Enter] or [Space] keys.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "altKey",
+                "type": "boolean",
+                "description": "Returns whether the \"ALT\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "ctrlKey",
+                "type": "boolean",
+                "description": "Returns whether the \"CTRL\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "metaKey",
+                "type": "boolean",
+                "description": "Returns whether the \"META\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "shiftKey",
+                "type": "boolean",
+                "description": "Returns whether the \"SHIFT\" key was pressed when the event was triggered."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "SideNavigationItemAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n**Note:** Do not use it on parent items, as it will be overridden if the item is in the overflow menu.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "SideNavigationItemDesign | \"Default\" | \"Action\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "Design for items that perform navigation, contain navigation child items, or both."
+              },
+              {
+                "value": "\"Action\"",
+                "description": "Design for items that trigger an action, such as opening a dialog.\n\n**Note:** Items with this design must not have sub-items.\n\n**Note:** Items that open a dialog must set `hasPopup=\"dialog\"` via `accessibilityAttributes` property."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Action\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Item design.\n\n**Note:** Items with \"Action\" design must not have sub-items.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "href": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the link target URI. Supports standard hyperlink behavior.\nIf a JavaScript action should be triggered,\nthis should not be set, but instead an event handler\nfor the `click` event should be registered.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**."
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon of the item.\n\n**Note:** Icons on second-level (child) navigation items are not recommended according to the design specification.\n\nThe SAP-icons font provides numerous options.\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the item is selected.\n\n**Note:** Items that have a set `href` and `target` set to `_blank` should not be selectable.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "target": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the component target.\n\nPossible values:\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `framename`\n\n**Note:** Items that have a defined `href` and `target`\nattribute set to `_blank` should not be selectable.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**."
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the item."
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\nA tooltip attribute should be provided, in order to represent meaning/function,\nwhen the component is collapsed (\"icon only\" design is visualized) or the item text is truncated.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**."
+        },
+        "unselectable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the navigation item is selectable. By default, all items are selectable unless specifically marked as unselectable.\n\nWhen a parent item is marked as unselectable, selecting it will only expand or collapse its sub-items.\nTo improve user experience do not mix unselectable parent items with selectable parent items in a single side navigation.\n\n\n**Guidelines**:\n- Items with an assigned `href` and a target of `_blank` should be marked as unselectable.\n- Items that trigger actions (with design \"Action\") should be marked as unselectable.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SideNavigationSubItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Slider": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The Slider component represents a numerical range and a handle (grip).\nThe purpose of the component is to enable visual selection of a value in\na continuous numerical range by moving an adjustable handle.\n\n### Structure\nThe most important properties of the Slider are:\n\n- min - The minimum value of the slider range.\n- max - The maximum value of the slider range.\n- value - The current value of the slider range.\n- step - Determines the increments in which the slider will move.\n- showTooltip - Determines if a tooltip should be displayed above the handle.\n- showTickmarks - Displays a visual divider between the step values.\n- labelInterval - Labels some or all of the tickmarks with their values.\n\n### Usage\nThe most common use case is to select values on a continuous numerical scale (e.g. temperature, volume, etc. ).\n\n### Responsive Behavior\nThe `Slider` component adjusts to the size of its parent container by recalculating and\nresizing the width of the control. You can move the slider handle in several different ways:\n\n- Drag and drop the handle to the desired value.\n- Click/tap on the range bar to move the handle to that location.\n\n### Keyboard Handling\n\n- `Left or Down Arrow` - Moves the handle one step to the left, effectively decreasing the component's value by `step` amount;\n- `Right or Up Arrow` - Moves the handle one step to the right, effectively increasing the component's value by `step` amount;\n- `Left or Down Arrow + Ctrl/Cmd` - Moves the handle to the left with step equal to 1/10th of the entire range, effectively decreasing the component's value by 1/10th of the range;\n- `Right or Up Arrow + Ctrl/Cmd` - Moves the handle to the right with step equal to 1/10th of the entire range, effectively increasing the component's value by 1/10th of the range;\n- `Plus` - Same as `Right or Up Arrow`;\n- `Minus` - Same as `Left or Down Arrow`;\n- `Home` - Moves the handle to the beginning of the range;\n- `End` - Moves the handle to the end of the range;\n- `Page Up` - Same as `Right or Up + Ctrl/Cmd`;\n- `Page Down` - Same as `Left or Down + Ctrl/Cmd`;\n- `Escape` - Resets the value property after interaction, to the position prior the component's focusing;\n\n\n\n__Note:__ This is a UI5 Web Component! [Slider UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Slider) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SliderDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value changes and the user has finished interacting with the slider.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SliderDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value changes due to user interaction that is not yet finished - during mouse/touch dragging.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the slider is in disabled state.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "editableTooltip": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether input fields should be used as tooltips for the handles.\n\n**Note:** Setting this option to true will only work if showTooltip is set to true.\n**Note:** In order for the component to comply with the accessibility standard, it is recommended to set the editableTooltip property to true.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "labelInterval": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Displays a label with a value on every N-th step.\n\n**Note:** The step and tickmarks properties must be enabled.\nExample - if the step value is set to 2 and the label interval is also specified to 2 - then every second\ntickmark will be labelled, which means every 4th value number.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "max": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the maximum value of the slider.",
+          "defaultValue": {
+            "value": "100"
+          }
+        },
+        "min": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the minimum value of the slider.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
+        },
+        "showTickmarks": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Enables tickmarks visualization for each step.\n\n**Note:** The step must be a positive number.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showTooltip": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Enables handle tooltip displaying the current value.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "step": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the size of the slider's selection intervals (e.g. min = 0, max = 10, step = 5 would result in possible selection of the values 0, 5, 10).\n\n**Note:** If set to 0 the slider handle movement is disabled.",
+          "defaultValue": {
+            "value": "1"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Current value of the slider",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SliderDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "handle",
+          "description": "Used to style the handle of the `ui5-slider`."
+        },
+        {
+          "name": "progress-bar",
+          "description": "Used to style the progress bar, which shows the progress of the `ui5-slider`."
+        },
+        {
+          "name": "progress-container",
+          "description": "Used to style the progress container, the horizontal bar that visually represents the range between the minimum and maximum values, of the `ui5-slider`."
+        }
+      ]
+    },
+    "SortItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `SortItem` component defines the sorting criteria for data in `ViewSettingsDialog`.\nIt represents a single sort option that users can select to organize data in ascending or descending order.\n\n### Usage\n\nThe `SortItem` is used within the `ViewSettingsDialog` to provide sorting options.\nEach sort item represents a column or field by which data can be sorted.\n\n\n\n__Note:__ This is a UI5 Web Component! [SortItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SortItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the sort item is selected.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the sort item."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SortItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SpecialCalendarDate": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `SpecialCalendarDate` component defines a special calendar date to be used inside `Calendar`,\nwhich is visually distinguished from the rest of the dates.\n\n__Note:__ This is a UI5 Web Component! [SpecialCalendarDate UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SpecialCalendarDate) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "CalendarLegendItemType | \"Today\" | \"Selected\" | \"None\" | \"Working\" | \"NonWorking\" | \"Type01\" | \"Type02\" | \"Type03\" | \"Type04\" | \"Type05\" | \"Type06\" | ... 13 more ... | \"Type20\"",
+            "value": [
+              {
+                "value": "\"Today\"",
+                "description": "Represents the \"Today\" item in the calendar legend."
+              },
+              {
+                "value": "\"Selected\"",
+                "description": "Represents the \"Selected\" item in the calendar legend."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Set when no type is set."
+              },
+              {
+                "value": "\"Working\"",
+                "description": "Represents the \"Working\" item in the calendar legend."
+              },
+              {
+                "value": "\"NonWorking\"",
+                "description": "Represents the \"NonWorking\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type01\"",
+                "description": "Represents the \"Type01\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type02\"",
+                "description": "Represents the \"Type02\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type03\"",
+                "description": "Represents the \"Type03\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type04\"",
+                "description": "Represents the \"Type04\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type05\"",
+                "description": "Represents the \"Type05\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type06\"",
+                "description": "Represents the \"Type06\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type07\"",
+                "description": "Represents the \"Type07\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type08\"",
+                "description": "Represents the \"Type08\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type09\"",
+                "description": "Represents the \"Type09\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type10\"",
+                "description": "Represents the \"Type10\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type11\"",
+                "description": "Represents the \"Type11\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type12\"",
+                "description": "Represents the \"Type12\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type13\"",
+                "description": "Represents the \"Type13\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type14\"",
+                "description": "Represents the \"Type14\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type15\"",
+                "description": "Represents the \"Type15\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type16\"",
+                "description": "Represents the \"Type16\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type17\"",
+                "description": "Represents the \"Type17\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type18\"",
+                "description": "Represents the \"Type18\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type19\"",
+                "description": "Represents the \"Type19\" item in the calendar legend."
+              },
+              {
+                "value": "\"Type20\"",
+                "description": "Represents the \"Type20\" item in the calendar legend."
+              },
+              {
+                "value": "\"Today\""
+              },
+              {
+                "value": "\"Selected\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Working\""
+              },
+              {
+                "value": "\"NonWorking\""
+              },
+              {
+                "value": "\"Type01\""
+              },
+              {
+                "value": "\"Type02\""
+              },
+              {
+                "value": "\"Type03\""
+              },
+              {
+                "value": "\"Type04\""
+              },
+              {
+                "value": "\"Type05\""
+              },
+              {
+                "value": "\"Type06\""
+              },
+              {
+                "value": "\"Type07\""
+              },
+              {
+                "value": "\"Type08\""
+              },
+              {
+                "value": "\"Type09\""
+              },
+              {
+                "value": "\"Type10\""
+              },
+              {
+                "value": "\"Type11\""
+              },
+              {
+                "value": "\"Type12\""
+              },
+              {
+                "value": "\"Type13\""
+              },
+              {
+                "value": "\"Type14\""
+              },
+              {
+                "value": "\"Type15\""
+              },
+              {
+                "value": "\"Type16\""
+              },
+              {
+                "value": "\"Type17\""
+              },
+              {
+                "value": "\"Type18\""
+              },
+              {
+                "value": "\"Type19\""
+              },
+              {
+                "value": "\"Type20\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the type of the special date.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "The date formatted according to the `formatPattern` property\nof the `Calendar` that hosts the component."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SpecialCalendarDateDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SplitButton": {
+      "package": "@ui5/webcomponents-react",
+      "description": "`SplitButton` enables users to trigger actions. It is constructed of two separate actions -\ndefault action and arrow action that can be activated by clicking or tapping, or by\npressing certain keyboard keys - `Space` or `Enter` for default action,\nand `Arrow Down` or `Arrow Up` for arrow action.\n\n### Usage\n\n`SplitButton` consists two separate buttons:\n\n- for the first one (default action) you can define some `text` or an `icon`, or both.\n- the second one (arrow action) contains only `slim-arrow-down` icon.\n\nYou can choose a `design` from a set of predefined types (the same as for ui5-button) that offer\ndifferent styling to correspond to the triggered action. Both text and arrow actions have the same design.\n\nYou can set the `SplitButton` as enabled or disabled. Both parts of an enabled\n`SplitButton` can be pressed by clicking or tapping it, or by certain keys, which changes\nthe style to provide visual feedback to the user that it is pressed or hovered over with\nthe mouse cursor. A disabled `SplitButton` appears inactive and any of the two buttons\ncannot be pressed.\n\n### Keyboard Handling\n\n- `Space` or `Enter` - triggers the default action\n- `Shift` or `Escape` - if `Space` is pressed, releases the default action button without triggering the click event.\n- `Arrow Down`, `Arrow Up`, `Alt`+`Arrow Down`, `Alt`+`Arrow Up`, or `F4` - triggers the arrow action\nThere are separate events that are fired on activating of `SplitButton` parts:\n\n- `click` for the first button (default action)\n- `arrow-click` for the second button (arrow action)\n\n\n\n__Note:__ This is a UI5 Web Component! [SplitButton UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SplitButton) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "onArrowClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SplitButtonDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on the arrow action.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SplitButtonDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on the default action.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "SplitButtonAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe `accessibilityAttributes` property accepts an object with the following optional fields:\n\n- **root**: Attributes that will be applied to the main (text) button.\n  - **hasPopup**: Indicates the presence and type of popup triggered by the button.\n    Accepts string values: `\"dialog\"`, `\"grid\"`, `\"listbox\"`, `\"menu\"`, or `\"tree\"`.\n  - **roleDescription**: Provides a human-readable description for the role of the button.\n    Accepts any string value.\n  - **title**: Specifies a tooltip or description for screen readers.\n    Accepts any string value.\n\t- **ariaKeyShortcuts**: Defines keyboard shortcuts that activate or give focus to the button.\n\n- **arrowButton**: Attributes applied specifically to the arrow (split) button.\n  - **hasPopup**: Indicates the presence and type of popup triggered by the arrow button.\n    Accepts string values: `\"dialog\"`, `\"grid\"`, `\"listbox\"`, `\"menu\"`, or `\"tree\"`.\n  - **expanded**: Indicates whether the popup triggered by the arrow button is currently expanded.\n    Accepts boolean values: `true` or `false`.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "activeArrowButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the arrow button should have the active state styles or not.\n\n**Note:** Available since [v1.21.0](https://github.com/UI5/webcomponents/releases/tag/v1.21.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "ButtonDesign | \"Default\" | \"Positive\" | \"Negative\" | \"Transparent\" | \"Emphasized\" | \"Attention\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "default type (no special styling)"
+              },
+              {
+                "value": "\"Positive\"",
+                "description": "accept type (green button)"
+              },
+              {
+                "value": "\"Negative\"",
+                "description": "reject style (red button)"
+              },
+              {
+                "value": "\"Transparent\"",
+                "description": "transparent type"
+              },
+              {
+                "value": "\"Emphasized\"",
+                "description": "emphasized type"
+              },
+              {
+                "value": "\"Attention\"",
+                "description": "attention type"
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Transparent\""
+              },
+              {
+                "value": "\"Emphasized\""
+              },
+              {
+                "value": "\"Attention\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component design.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\nExample:\n\nSee all available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SplitButtonDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "button",
+          "description": "Used to style the native button element"
+        },
+        {
+          "name": "endIcon",
+          "description": "Used to style the end icon in the native button element"
+        },
+        {
+          "name": "icon",
+          "description": "Used to style the icon in the native button element"
+        }
+      ]
+    },
+    "StepInput": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `StepInput` consists of an input field and buttons with icons to increase/decrease the value\nwith the predefined step.\n\nThe user can change the value of the component by pressing the increase/decrease buttons,\nby typing a number directly, by using the keyboard up/down and page up/down,\nor by using the mouse scroll wheel. Decimal values are supported.\n\n### Usage\n\nThe default step is 1 but the app developer can set a different one.\n\nApp developers can set a maximum and minimum value for the `StepInput`.\nThe increase/decrease button and the up/down keyboard navigation become disabled when\nthe value reaches the max/min or a new value is entered from the input which is greater/less than the max/min.\n\n#### When to use:\n\n- To adjust amounts, quantities, or other values quickly.\n- To adjust values for a specific step.\n\n#### When not to use:\n\n- To enter a static number (for example, postal code, phone number, or ID). In this case,\nuse the regular `Input` instead.\n- To display a value that rarely needs to be adjusted and does not pertain to a particular step.\nIn this case, use the regular `Input` instead.\n- To enter dates and times. In this case, use date/time related components instead.\n\n\n\n__Note:__ This is a UI5 Web Component! [StepInput UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/StepInput) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<StepInputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<StepInputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the component changes at each keystroke.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onValueStateChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<StepInputDomRef, StepInputValueStateChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the value state of the component is updated internally.\nThe event is preventable, meaning that if it's default action is\nprevented, the component will not update the value state.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in between the min and max value."
+              },
+              {
+                "name": "valueState",
+                "type": "string",
+                "description": "The new `valueState` that will be set."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is displayed as disabled.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "max": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines a maximum value of the component."
+        },
+        "min": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines a minimum value of the component."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint, intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** When no placeholder is set, the format pattern is displayed as a placeholder.\nPassing an empty string as the value of this property will make the component appear empty - without placeholder or format pattern."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is displayed as read-only.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "step": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines a step of increasing/decreasing the value of the component.",
+          "defaultValue": {
+            "value": "1"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines a value of the component.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "valuePrecision": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Determines the number of digits after the decimal point of the component.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<StepInputDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SuggestionItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `SuggestionItem` represents the suggestion item of the `Input`.\n\n__Note:__ This is a UI5 Web Component! [SuggestionItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SuggestionItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "additionalText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `additionalText`, displayed in the end of the item."
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the component."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SuggestionItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SuggestionItemCustom": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `SuggestionItemCustom` is type of suggestion item,\nthat can be used to place suggestion items with custom content in the input.\nThe text property is considered only for autocomplete.\nIn case the user needs highlighting functionality, check \"@ui5/webcomponents-base/dist/util/generateHighlightedMarkup.js\"\n\n__Note:__ This is a UI5 Web Component! [SuggestionItemCustom UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SuggestionItemCustom) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the `SuggestionItemCustom`.\n**Note:** The text property is considered only for autocomplete."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SuggestionItemCustomDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "SuggestionItemGroup": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `SuggestionItemGroup` is type of suggestion item,\nthat can be used to split the `Input` suggestions into groups.\n\n__Note:__ This is a UI5 Web Component! [SuggestionItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SuggestionItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the <code>ui5-suggestion-item-group</code>.\n\n__Supported Node Type/s:__ `Array<SuggestionListItem>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
+        },
+        "onMove": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SuggestionItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMoveOver": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SuggestionItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "headerAccessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the header."
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text of the <code>ui5-li-group</code>."
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "WrappingType | \"None\" | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ExpandableText` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SuggestionItemGroupDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "header",
+          "description": "Used to style the header item of the group"
+        },
+        {
+          "name": "title",
+          "description": "Used to style the title of the group header"
+        }
+      ]
+    },
+    "Switch": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Switch` component is used for changing between binary states.\n\nThe component can display texts, that will be switched, based on the component state, via the `textOn` and `textOff` properties,\nbut texts longer than 3 letters will be cutted off.\n\nHowever, users are able to customize the width of `Switch` with pure CSS (`<Switch style=\"width: 200px\">`), and set widths, depending on the texts they would use.\n\nNote: the component would not automatically stretch to fit the whole text width.\n\n### Keyboard Handling\nThe state can be changed by pressing the Space and Enter keys.\n\n\n\n__Note:__ This is a UI5 Web Component! [Switch UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Switch) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<SwitchDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component checked state changes.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Sets the accessible ARIA name of the component.\n\n**Note**: We recommend that you set an accessibleNameRef pointing to an external label or at least an `accessibleName`.\nProviding an `accessibleNameRef` or an `accessibleName` is mandatory in the cases when `textOn` and `textOff` properties aren't set.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note**: We recommend that you set an accessibleNameRef pointing to an external label or at least an `accessibleName`.\nProviding an `accessibleNameRef` or an `accessibleName` is mandatory in the cases when `textOn` and `textOff` properties aren't set.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "checked": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the component is checked.\n\n**Note:** The property can be changed with user interaction,\neither by cliking the component, or by pressing the `Enter` or `Space` key.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "SwitchDesign | \"Textual\" | \"Graphical\"",
+            "value": [
+              {
+                "value": "\"Textual\"",
+                "description": "Defines the Switch as Textual"
+              },
+              {
+                "value": "\"Graphical\"",
+                "description": "Defines the Switch as Graphical"
+              },
+              {
+                "value": "\"Textual\""
+              },
+              {
+                "value": "\"Graphical\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component design.\n\n**Note:** If `Graphical` type is set,\npositive and negative icons will replace the `textOn` and `textOff`.",
+          "defaultValue": {
+            "value": "\"Textual\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\n\n**Note:** A disabled component is noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v1.16.0](https://github.com/UI5/webcomponents/releases/tag/v1.16.0) of **@ui5/webcomponents**."
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.\n\n**Note:** Available since [v1.16.0](https://github.com/UI5/webcomponents/releases/tag/v1.16.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "textOff": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text, displayed when the component is not checked.\n\n**Note:** We recommend using short texts, up to 3 letters (larger texts would be cut off)."
+        },
+        "textOn": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text, displayed when the component is checked.\n\n**Note:** We recommend using short texts, up to 3 letters (larger texts would be cut off)."
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\n**Note:** If applicable an external label reference should always be the preferred option to provide context to the `Switch` component over a tooltip.\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**."
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the form value of the component.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents**."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<SwitchDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "handle",
+          "description": "Used to style the handle of the switch"
+        },
+        {
+          "name": "slider",
+          "description": "Used to style the track, where the handle is being slid"
+        },
+        {
+          "name": "text-off",
+          "description": "Used to style the `textOff` property text"
+        },
+        {
+          "name": "text-on",
+          "description": "Used to style the `textOn` property text"
+        }
+      ]
+    },
+    "Tab": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Tab` represents a selectable item inside a `TabContainer`.\nIt defines both the item in the tab strip (top part of the `TabContainer`) and the\ncontent that is presented to the user once the tab is selected.\n\n__Note:__ This is a UI5 Web Component! [Tab UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Tab) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Holds the content associated with this tab.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "items": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines hierarchies with nested sub tabs.\n\n**Note:** Use `Tab` and `TabSeparator` for the intended design.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"items\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ITab>`"
+        },
+        "additionalText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Represents the \"additionalText\" text, which is displayed in the tab. In the cases when in the same time there are tabs with icons and tabs without icons, if a tab has no icon the \"additionalText\" is displayed larger."
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "SemanticColor | \"Default\" | \"Positive\" | \"Negative\" | \"Critical\" | \"Neutral\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "Default color (brand color)"
+              },
+              {
+                "value": "\"Positive\"",
+                "description": "Positive color"
+              },
+              {
+                "value": "\"Negative\"",
+                "description": "Negative color"
+              },
+              {
+                "value": "\"Critical\"",
+                "description": "Critical color"
+              },
+              {
+                "value": "\"Neutral\"",
+                "description": "Neutral color."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Neutral\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component's design color.\n\nThe design is applied to:\n\n- the component icon\n- the `text` when the component overflows\n- the tab selection line\n\nAvailable designs are: `\"Default\"`, `\"Neutral\"`, `\"Positive\"`, `\"Critical\"` and `\"Negative\"`.\n\n**Note:** The design depends on the current theme.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Disabled tabs can't be selected.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon source URI to be displayed as graphical element within the component.\nThe SAP-icons font provides numerous built-in icons.\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "movable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the tab is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Specifies if the component is selected.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "The text to be displayed for the item."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TabDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "getDomRefInStrip",
+          "description": "Returns the DOM reference of the tab that is placed in the header. **Note:** Tabs, placed in the `items` slot of other tabs are not shown in the header. Calling this method on such tabs will return `undefined`. **Note:** If you need a DOM ref to the tab content please use the `getDomRef` method.",
+          "params": [],
+          "returns": {
+            "type": "HTMLElement | undefined"
+          }
+        }
+      ]
+    },
+    "TabContainer": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TabContainer` represents a collection of tabs with associated content.\nNavigation through the tabs changes the content display of the currently active content area.\nA tab can be labeled with text only, or icons with text.\n\n### Structure\n\nThe `TabContainer` can hold two types of entities:\n\n- `Tab` - contains all the information on an item (text and icon)\n- `TabSeparator` - used to separate tabs with a line\n\n### Hierarchies\nMultiple sub tabs could be placed underneath one main tab. Nesting allows deeper hierarchies with indentations\nto indicate the level of each nested tab. When a tab has both sub tabs and own content its click area is split\nto allow the user to display the content or alternatively to expand / collapse the list of sub tabs.\n\n### Keyboard Handling\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n`import \"@ui5/webcomponents/dist/Tab.js\";` (for `Tab`)\n\n`import \"@ui5/webcomponents/dist/TabSeparator.js\";` (for `TabSeparator`)\n\n__Note:__ This is a UI5 Web Component! [TabContainer UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TabContainer) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the tabs.\n\n**Note:** Use `Tab` and `TabSeparator` for the intended design.\n\n__Supported Node Type/s:__ `Array<ITab>`"
+        },
+        "overflowButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the button which will open the overflow menu. If nothing is provided to this slot,\nthe default button will be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"overflowButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "startOverflowButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the button which will open the start overflow menu if available. If nothing is provided to this slot,\nthe default button will be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"startOverflowButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "onMove": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TabContainerDomRef, TabContainerMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when element is moved to the tab container.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMoveOver": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TabContainerDomRef, TabContainerMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when element is being moved over the tab container.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onTabSelect": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TabContainerDomRef, TabContainerTabSelectEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a tab is selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "tab",
+                "type": "Tab",
+                "description": "The selected `tab`."
+              },
+              {
+                "name": "tabIndex",
+                "type": "Integer",
+                "description": "The selected `tab` index in the flattened array of all tabs and their subTabs, provided by the `allItems` getter."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "collapsed": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the tab content is collapsed.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "contentBackgroundDesign": {
+          "type": {
+            "name": "enum",
+            "raw": "BackgroundDesign | \"Solid\" | \"Transparent\" | \"Translucent\"",
+            "value": [
+              {
+                "value": "\"Solid\"",
+                "description": "A solid background color dependent on the theme."
+              },
+              {
+                "value": "\"Transparent\"",
+                "description": "Transparent background."
+              },
+              {
+                "value": "\"Translucent\"",
+                "description": "A translucent background depending on the opacity value of the theme."
+              },
+              {
+                "value": "\"Solid\""
+              },
+              {
+                "value": "\"Transparent\""
+              },
+              {
+                "value": "\"Translucent\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Sets the background color of the Tab Container's content as `Solid`, `Transparent`, or `Translucent`.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Solid\""
+          }
+        },
+        "headerBackgroundDesign": {
+          "type": {
+            "name": "enum",
+            "raw": "BackgroundDesign | \"Solid\" | \"Transparent\" | \"Translucent\"",
+            "value": [
+              {
+                "value": "\"Solid\"",
+                "description": "A solid background color dependent on the theme."
+              },
+              {
+                "value": "\"Transparent\"",
+                "description": "Transparent background."
+              },
+              {
+                "value": "\"Translucent\"",
+                "description": "A translucent background depending on the opacity value of the theme."
+              },
+              {
+                "value": "\"Solid\""
+              },
+              {
+                "value": "\"Transparent\""
+              },
+              {
+                "value": "\"Translucent\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Sets the background color of the Tab Container's header as `Solid`, `Transparent`, or `Translucent`.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Solid\""
+          }
+        },
+        "noAutoSelection": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if automatic tab selection is deactivated.\n\n**Note:** By default, if none of the child tabs have the `selected` property set, the first tab will be automatically selected.\nSetting this property to `true` allows preventing this behavior.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "overflowMode": {
+          "type": {
+            "name": "enum",
+            "raw": "OverflowMode | \"End\" | \"StartAndEnd\"",
+            "value": [
+              {
+                "value": "\"End\"",
+                "description": "End type is used if there should be only one overflow with hidden the tabs at the end of the tab container."
+              },
+              {
+                "value": "\"StartAndEnd\"",
+                "description": "StartAndEnd type is used if there should be two overflows on both ends of the tab container."
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"StartAndEnd\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the overflow mode of the header (the tab strip). If you have a large number of tabs, only the tabs that can fit on screen will be visible.\nAll other tabs that can 't fit on the screen are available in an overflow tab \"More\".\n\n**Note:**\nOnly one overflow at the end would be displayed by default,\nbut when set to `StartAndEnd`, there will be two overflows on both ends, and tab order will not change on tab selection.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"End\""
+          }
+        },
+        "tabLayout": {
+          "type": {
+            "name": "enum",
+            "raw": "TabLayout | \"Inline\" | \"Standard\"",
+            "value": [
+              {
+                "value": "\"Inline\"",
+                "description": "Inline type, the tab \"main text\" and \"additionalText\" are displayed horizotally."
+              },
+              {
+                "value": "\"Standard\"",
+                "description": "Standard type, the tab \"main text\" and \"additionalText\" are displayed vertically."
+              },
+              {
+                "value": "\"Inline\""
+              },
+              {
+                "value": "\"Standard\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the alignment of the content and the `additionalText` of a tab.\n\n**Note:**\nThe content and the `additionalText` would be displayed vertically by default,\nbut when set to `Inline`, they would be displayed horizontally.",
+          "defaultValue": {
+            "value": "\"Standard\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TabContainerDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "content",
+          "description": "Used to style the content of the component"
+        },
+        {
+          "name": "tabstrip",
+          "description": "Used to style the tabstrip of the component"
+        }
+      ]
+    },
+    "TabSeparator": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TabSeparator` represents a vertical line to separate tabs inside a `TabContainer`.\n\n__Note:__ This is a UI5 Web Component! [TabSeparator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TabSeparator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TabSeparatorDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "getDomRefInStrip",
+          "description": "Returns the DOM reference of the separator that is placed in the header. **Note:** Separators, placed in the `items` slot of other tabs are not shown in the header. Calling this method on such separators will return `undefined`.",
+          "params": [],
+          "returns": {
+            "type": "HTMLElement | undefined"
+          }
+        }
+      ]
+    },
+    "Table": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Table` component provides a set of sophisticated features for displaying and dealing with vast amounts of data in a responsive manner.\nTo render the `Table`, you need to define the columns and rows. You can use the provided `TableHeaderRow` and `TableRow` components for this purpose.\n\n### Features\n\nThe `Table` can be enhanced in its functionalities by applying different features.\nFeatures can be slotted into the `features` slot, to enable them in the component.\nFeatures need to be imported separately, as they are not enabled by default.\n\nThe following features are currently available:\n\n* [TableSelectionMulti](../TableSelectionMulti) - adds multi-selection capabilities to the table\n* [TableSelectionSingle](../TableSelectionSingle) - adds single-selection capabilities to the table\n* [TableGrowing](../TableGrowing) - provides growing capabilities to load more data\n* [TableVirtualizer](../TableVirtualizer) - adds virtualization capabilities to the table\n\n### Keyboard Handling\n\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\nFurthermore, you can interact with `Table` via the following keys:\n\nIf the focus is on a row, the following keyboard shortcuts are available:\n* <kbd>Down</kbd> - Navigates down\n* <kbd>Up</kbd> - Navigates up\n* <kbd>Right</kbd> - Selects the first cell of the row\n* <kbd>Space</kbd> - Toggles the selection of the row\n* <kbd>Ctrl/Cmd + A</kbd> - In multi selection mode, toggles the selection of all rows\n* <kbd>Home</kbd> - Navigates to the first row, if the focus is on the first row, navigates to the header row\n* <kbd>End</kbd> - Navigates to the last row, if the focus is on the last row, navigates to the growing button\n* <kbd>Page Up</kbd> - Navigates one page up, if the focus is on the first row, navigates to the header row\n* <kbd>Page Down</kbd> - Navigates one page down, if the focus is on the last row, navigates to the growing button\n* <kbd>F2</kbd> - Focuses the first tabbable element in the row\n* <kbd>F7</kbd> - If focus position is remembered, moves focus to the corresponding focus position row, otherwise to the first tabbable element within the row\n* <kbd>[Shift]Tab</kbd> - Move focus to the element in the tab chain outside the table\n\nIf the focus is on a cell, the following keyboard shortcuts are available:\n* <kbd>Down</kbd> - Navigates down\n* <kbd>Up</kbd> - Navigates up\n* <kbd>Right</kbd> - Navigates right\n* <kbd>Left</kbd> - Navigates left, if the focus is on the first cell of the row, the focus is moved to the row.\n* <kbd>Home</kbd> - Navigates to the first cell of the current row, if the focus is on the first cell, navigates to the corresponding row\n* <kbd>End</kbd> - Navigates to the last cell of the current row, if the focus is on the last cell, navigates to the corresponding row\n* <kbd>Page Up</kbd> - Navigates one page up while keeping the focus in same column\n* <kbd>Page Down</kbd> - Navigates one page down while keeping the focus in same column\n* <kbd>F2</kbd> - Toggles the focus between the first tabbable cell content and the cell\n* <kbd>Enter</kbd> - Focuses the first tabbable cell content\n* <kbd>F7</kbd> - If the focus is on an interactive element inside a row, moves focus to the corresponding row and remembers the focus position of the element within the row\n* <kbd>[Shift]Tab</kbd> - Move focus to the element in the tab chain outside the table\n\nIf the focus is on an interactive cell content, the following keyboard shortcuts are available:\n* <kbd>Down</kbd> - Move the focus to the interactive element in the same column of the previous row, unless the focused element prevents the default\n* <kbd>Up</kbd> - Move the focus to the interactive element in the same column of the next row, unless the focused element prevents the default\n* <kbd>[Shift]Tab</kbd> - Move the focus to the element in the tab chain\n\n### Accessibility\n\nThe `Table` follows the [ARIA grid design pattern](https://www.w3.org/WAI/ARIA/apg/patterns/grid/).\nThis pattern enables cell-based keyboard navigation and, as explained above, we also support row-based keyboard navigation.\nSince the grid design pattern does not inherently provide row-based keyboard behavior, if the focus is on a row, not only the row information but also the corresponding column headers for each cell must be announced.\nThis can only be achieved through a custom accessibility announcement.\nTo support this, UI5 Web Components expose its own accessibility metadata via the `accessibilityInfo` property.\nThe `Table` uses this information to create the required custom announcements dynamically.\nIf you include custom web components inside table cells that are not part of the standard UI5 Web Components set, their accessibility information can be provided using the `data-ui5-acc-text` attribute.\n\n)\\\n`import \"@ui5/webcomponents/dist/TableRow.js\";` (`TableRow`)\\\n`import \"@ui5/webcomponents/dist/TableCell.js\";` (`TableCell`)\\\n`import \"@ui5/webcomponents/dist/TableHeaderRow.js\";` (`TableHeaderRow`)\\\n`import \"@ui5/webcomponents/dist/TableHeaderCell.js\";` (`TableHeaderCell`)\n\n__Note:__ This is a UI5 Web Component! [Table UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Table) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the rows of the component.\n\n**Note:** Use `TableRow` for the intended design.\n\n__Supported Node Type/s:__ `Array<TableRow>`"
+        },
+        "features": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the features of the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"features\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ITableFeature>`"
+        },
+        "headerRow": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header row of the component.\n\n**Note:** Use `TableHeaderRow` for the intended design.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"headerRow\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<TableHeaderRow>`"
+        },
+        "noData": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the custom visualization if there is no data available.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"noData\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onMove": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableDomRef, MoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Notes:**\n\nThe `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\nIf the dragging operation is a cross-browser operation or files are moved to a potential drop target,\nthe `source` parameter will be `null`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "The destination object"
+              },
+              {
+                "name": "originalEvent",
+                "type": "Event",
+                "description": "The original `drop` event"
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "The source object"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMoveOver": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableDomRef, MoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** If the dragging operation is a cross-browser operation or files are moved to a potential drop target,\nthe `source` parameter will be `null`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "The destination object"
+              },
+              {
+                "name": "originalEvent",
+                "type": "Event",
+                "description": "The original `dragover` event"
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "The source object"
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onRowActionClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableDomRef, TableRowActionClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a row action is clicked.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "action",
+                "type": "TableRowActionBase",
+                "description": "The row action instance"
+              },
+              {
+                "name": "row",
+                "type": "TableRow",
+                "description": "The row instance"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onRowClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableDomRef, TableRowClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when an interactive row is clicked.\n\n**Note:** This event is not fired if the `behavior` property of the selection component is set to `RowOnly`.\nIn that case, use the `change` event of the selection component instead.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "row",
+                "type": "TableRow",
+                "description": "The row instance"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Identifies the element (or elements) that labels the component."
+        },
+        "alternateRowColors": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the table rows are displayed with alternating background colors.\n\n**Note:** Available since [v2.17](https://github.com/UI5/webcomponents/releases/tag/v2.17) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the loading indicator should be shown.\n\n**Note:** When the component is loading, it is not interactive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the loading indicator will show up for this component.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "noDataText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text to be displayed when there are no rows in the component."
+        },
+        "overflowMode": {
+          "type": {
+            "name": "enum",
+            "raw": "TableOverflowMode | \"Scroll\" | \"Popin\"",
+            "value": [
+              {
+                "value": "\"Scroll\"",
+                "description": "Shows a scrollbar, when the table cannot fit all columns."
+              },
+              {
+                "value": "\"Popin\"",
+                "description": "Pops in columns, that do not fit into the table anymore."
+              },
+              {
+                "value": "\"Scroll\""
+              },
+              {
+                "value": "\"Popin\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the mode of the <code>ui5-table</code> overflow behavior.\n\nAvailable options are:\n\n<code>Scroll</code> - Columns are shown as regular columns and horizontal scrolling is enabled.\n<code>Popin</code> - Columns are shown as pop-ins instead of regular columns.",
+          "defaultValue": {
+            "value": "\"Scroll\""
+          }
+        },
+        "rowActionCount": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the maximum number of row actions that is displayed, which determines the width of the row action column.\n\n**Note:** It is recommended to use a maximum of 3 row actions, as exceeding this limit may take up too much space on smaller screens.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TableCell": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableCell` represents a cell inside of a `Table`.\nIt is tightly coupled to the `Table` and thus should only be used in the table component.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableCell UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableCell) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "horizontalAlign": {
+          "type": {
+            "name": "enum",
+            "raw": "TableCellHorizontalAlign | \"Left\" | \"Start\" | \"Right\" | \"End\" | \"Center\"",
+            "value": [
+              {
+                "value": "\"Left\""
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"Right\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Left\""
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"Right\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Center\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the horizontal alignment of table cells."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableCellDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TableGrowing": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableGrowing` component is used inside the `Table` to add a growing/data loading functionalities\nto the table.\n\nThe component offers two options:\n* Button - a More button is displayed, clicking it will load more data.\n* Scroll - additional data is loaded automatically when the user scrolls to the end of the table.\n\n### Usage\n\nThe `TableGrowing` component is only used inside the `Table` component as a feature.\nIt has to be slotted inside the `Table` in the `features` slot.\nThe component is not intended to be used as a standalone component.\n\n```html\n<Table>\n\t<TableGrowing mode=\"Button\" text=\"More\" slot=\"features\"></TableGrowing>\n</Table>\n```\n\n**Notes**:\n* When the `TableGrowing` component is used with the `Scroll` mode and the table is currently not scrollable,\nthe component will render a growing button instead to ensure growing capabilities until the table becomes scrollable.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableGrowing UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableGrowing) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onLoadMore": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableGrowingDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the growing button is pressed or the user scrolls to the end of the table.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "mode": {
+          "type": {
+            "name": "enum",
+            "raw": "TableGrowingMode | \"Button\" | \"Scroll\"",
+            "value": [
+              {
+                "value": "\"Button\"",
+                "description": "Renders a growing button, which can be pressed to load more data."
+              },
+              {
+                "value": "\"Scroll\"",
+                "description": "Scroll to load more data.\n\n**Note:** If the table is not scrollable, a growing button will be rendered instead to ensure growing functionality."
+              },
+              {
+                "value": "\"Button\""
+              },
+              {
+                "value": "\"Scroll\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the mode of the <code>ui5-table</code> growing.\n\nAvailable options are:\n\nButton - Shows a More button at the bottom of the table, pressing it will load more rows.\n\nScroll - The rows are loaded automatically by scrolling to the bottom of the table. If the table is not scrollable,\na growing button will be rendered instead to ensure growing functionality.",
+          "defaultValue": {
+            "value": "\"Button\""
+          }
+        },
+        "subtext": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text that will be displayed below the `text` inside the growing button.\nHas no effect when mode is set to Scroll."
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text that will be displayed inside the growing button.\nHas no effect when mode is set to `Scroll`.\n\n**Note:** When not provided and the mode is set to Button, a default text is displayed, corresponding to the\ncurrent language."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableGrowingDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TableHeaderCell": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableHeaderCell` component represents a column in the `Table`.\n\nAs it is tightly coupled to the `Table`, it should only be used in the `TableHeaderRow`\nto ensure correct layout and design.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableHeaderCell UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableHeaderCell) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "action": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the action of the column.\n\n**Note:** While multiple actions are technically possible, this is not supported.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"action\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<TableHeaderCellActionBase>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "horizontalAlign": {
+          "type": {
+            "name": "enum",
+            "raw": "TableCellHorizontalAlign | \"Left\" | \"Start\" | \"Right\" | \"End\" | \"Center\"",
+            "value": [
+              {
+                "value": "\"Left\""
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"Right\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Center\""
+              },
+              {
+                "value": "\"Left\""
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"Right\""
+              },
+              {
+                "value": "\"End\""
+              },
+              {
+                "value": "\"Center\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Determines the horizontal alignment of table cells."
+        },
+        "importance": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the importance of the column.\n\nThis property affects the popin behaviour.\nColumns with higher importance will move into the popin area later then less important\ncolumns.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "minWidth": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the minimum width of the column.\n\nIf the table is in `Popin` mode and the minimum width does not fit anymore,\nthe column will move into the popin.\n\nBy default, the table prevents the column from becoming too small.\nChanging this value to a small value might lead to accessibility issues.\n\n**Note:** This property only takes effect for columns with a [\\<percentage\\>](https://developer.mozilla.org/en-US/docs/Web/CSS/percentage) value\nor the default width."
+        },
+        "popinHidden": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the column is hidden in the popin.\n\n**Note:** Please be aware that hiding the column in the popin might lead to accessibility issues as\nusers might not be able to access the content of the column on small screens.\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "popinText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "The text for the column when it pops in.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**."
+        },
+        "sortIndicator": {
+          "type": {
+            "name": "enum",
+            "raw": "SortOrder | \"None\" | \"Ascending\" | \"Descending\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "Sorting is not applied."
+              },
+              {
+                "value": "\"Ascending\"",
+                "description": "Sorting is applied in ascending order."
+              },
+              {
+                "value": "\"Descending\"",
+                "description": "Sorting is applied in descending order."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Ascending\""
+              },
+              {
+                "value": "\"Descending\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the sort indicator of the column.\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "width": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the width of the column.\n\nBy default, the column will grow and shrink according to the available space.\nThis will distribute the space proportionally among all columns with no specific width set.\n\nSee [\\<length\\>](https://developer.mozilla.org/en-US/docs/Web/CSS/length) and\n[\\<percentage\\>](https://developer.mozilla.org/en-US/docs/Web/CSS/percentage) for possible width values."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableHeaderCellDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TableHeaderCellActionAI": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableHeaderCellActionAI` component defines a dedicated AI action for the table column.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableHeaderCellActionAI UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableHeaderCellActionAI) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableHeaderCellActionAIDomRef, TableHeaderCellActionClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a header cell action is clicked.\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "targetRef",
+                "type": "HTMLElement",
+                "description": "The reference to the element that triggered the event"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableHeaderCellActionAIDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TableHeaderRow": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableHeaderRow` component represents the table headers of a `Table`.\n\nIt is tightly coupled to the `Table` and should therefore be used in the `Table` only.\nThe header row is placed in the `headerRow` slot of the table.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableHeaderRow UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableHeaderRow) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the cells of the component.\n\n**Note:** Use `TableHeaderCell` for the intended design.\n\n__Supported Node Type/s:__ `Array<TableHeaderCell>`"
+        },
+        "sticky": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Sticks the `TableHeaderRow` to the top of a table.\n\nNote: If used in combination with overflowMode \"Scroll\", the table needs a defined height for the sticky header to work as expected.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableHeaderRowDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TableRow": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableRow` component represents a row in the `Table`.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableRow UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableRow) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "actions": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the actions of the component.\n\n**Note:** Use `TableRowAction` or `TableRowActionNavigation` for the intended design.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"actions\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<TableRowActionBase>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the cells of the component.\n\n**Note:** Use `TableCell` for the intended design.\n\n__Supported Node Type/s:__ `Array<TableCell>`"
+        },
+        "interactive": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the interactive state of the row.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "movable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the row is movable.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "navigated": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the navigated state of the row.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "position": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the 0-based position of the row related to the total number of rows within the table when the `TableVirtualizer` feature is used.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
+        },
+        "rowKey": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Unique identifier of the row.\n\n**Note:** For selection features to work properly, this property is mandatory, and its value must not contain spaces."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableRowDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TableRowAction": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableRowAction` component defines an action for table rows.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableRowAction UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableRowAction) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableRowActionDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when a row action is clicked.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon of the row action.\n\n**Note:** For row actions to work properly, this property is mandatory.\n\n**Note:** SAP-icons font provides numerous built-in icons. To find all the available icons, see the\n[Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "invisible": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the visibility of the row action.\n\n**Note:** Invisible row actions still take up space, allowing to hide the action while maintaining its position.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the row action.\n\n**Note:** For row actions to work properly, this property is mandatory."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableRowActionDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TableRowActionNavigation": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableRowActionNavigation` component defines a navigation action for table rows.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableRowActionNavigation UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableRowActionNavigation) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableRowActionNavigationDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when a row action is clicked.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "interactive": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the interactive state of the navigation action.\n@deprecated As of version 2.20.0, the navigation icon is deprecated.\nFor better accessibility, the interactive mode which renders a button, must be used instead. To handle the action, attach a listener to the `click` event.\nIf the navigation should be triggered when a row is pressed, set the row's `interactive` property and use the `row-click` event of the `ui5-table`.\nThis property will be removed in a future release.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "invisible": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the visibility of the row action.\n\n**Note:** Invisible row actions still take up space, allowing to hide the action while maintaining its position.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableRowActionNavigationDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TableSelection": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableSelection` component is used inside the `Table` to add key-based selection capabilities to the `Table`.\n\nThe component offers three selection modes:\n* Single - select a single row.\n* Multiple - select multiple rows.\n* None - no selection active.\n\nAs the selection is key-based, `TableRow` components need to define a unique `row-key` property.\n\n### Usage\n\nThe `TableSelection` component is only used inside the `Table` component as a feature.\nIt has to be slotted inside the `Table` in the `features` slot.\nThe component is not intended to be used as a standalone component.\n\n```html\n<Table>\n\t<TableSelection mode=\"Multiple\" slot=\"features\"></TableSelection>\n</Table>\n```\n\n\n\n__Note:__ This is a UI5 Web Component! [TableSelection UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableSelection) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableSelectionDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the selection is changed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "mode": {
+          "type": {
+            "name": "enum",
+            "raw": "TableSelectionMode | \"None\" | \"Single\" | \"Multiple\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "Default mode (no selection)."
+              },
+              {
+                "value": "\"Single\"",
+                "description": "Single selection mode (only one table row can be selected)."
+              },
+              {
+                "value": "\"Multiple\"",
+                "description": "Multi selection mode (more than one table row can be selected)."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Single\""
+              },
+              {
+                "value": "\"Multiple\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the selection mode.",
+          "defaultValue": {
+            "value": "\"Multiple\""
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the selected rows separated by a space."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableSelectionDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TableSelectionMulti": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableSelectionMulti` component is used inside the `Table` to add multi-selection capabilities to the `Table`.\nSince selection is key-based, each `TableRow` must define a unique `row-key` property.\n\n### Usage\n\nThe `TableSelectionMulti` component is a feature designed exclusively for use within the `Table` component.\nIt must be placed inside the `features` slot of `Table`.\nThis component is not intended for standalone use.\n\n```html\n<Table>\n\t<TableSelectionMulti slot=\"features\" selected=\"Row1 Row3\"></TableSelectionMulti>\n</Table>\n```\n\n\n\n__Note:__ This is a UI5 Web Component! [TableSelectionMulti UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableSelectionMulti) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableSelectionMultiDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the selection is changed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "behavior": {
+          "type": {
+            "name": "enum",
+            "raw": "TableSelectionBehavior | \"RowSelector\" | \"RowOnly\"",
+            "value": [
+              {
+                "value": "\"RowSelector\"",
+                "description": "Rows can only be selected by using the row selector column."
+              },
+              {
+                "value": "\"RowOnly\"",
+                "description": "Rows can only be selected by clicking directly on the row, as the row selector column is hidden.\n\n**Note:** In this mode, the `row-click` event of the `ui5-table` component is not fired."
+              },
+              {
+                "value": "\"RowSelector\""
+              },
+              {
+                "value": "\"RowOnly\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the selection behavior.\n\n**Note:** Available since [v2.11](https://github.com/UI5/webcomponents/releases/tag/v2.11) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"RowSelector\""
+          }
+        },
+        "headerSelector": {
+          "type": {
+            "name": "enum",
+            "raw": "TableSelectionMultiHeaderSelector | \"SelectAll\" | \"ClearAll\"",
+            "value": [
+              {
+                "value": "\"SelectAll\"",
+                "description": "Renders a checkbox in the table header row that toggles the selection of all rows."
+              },
+              {
+                "value": "\"ClearAll\"",
+                "description": "Renders an icon in the table header row that removes the selection of all rows."
+              },
+              {
+                "value": "\"SelectAll\""
+              },
+              {
+                "value": "\"ClearAll\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the selector of the header row.\n\n**Note:** Available since [v2.12](https://github.com/UI5/webcomponents/releases/tag/v2.12) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"SelectAll\""
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `row-key` values of selected rows, with each value separated by a space."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableSelectionMultiDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "getRowByKey",
+          "description": "Returns the table row instance for the given row key.",
+          "params": [
+            {
+              "name": "rowKey",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "TableRow | undefined"
+          }
+        },
+        {
+          "name": "getSelectedAsSet",
+          "description": "Returns the `selected` property as a set of unique `row-key` values.",
+          "params": [],
+          "returns": {
+            "type": "Set<string>"
+          }
+        },
+        {
+          "name": "getSelectedRows",
+          "description": "Returns an array of the selected rows.",
+          "params": [],
+          "returns": {
+            "type": "Array<TableRow>"
+          }
+        },
+        {
+          "name": "setSelectedAsSet",
+          "description": "Sets the `selected` property using the provided set of unique `row-key` values.",
+          "params": [
+            {
+              "name": "selectedSet",
+              "type": {
+                "name": "Set<string>"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "void"
+          }
+        }
+      ]
+    },
+    "TableSelectionSingle": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableSelectionSingle` component is used inside the `Table` to add single selection capabilities to the `Table`.\nSince selection is key-based, each `TableRow` must define a unique `row-key` property.\n\n### Usage\n\nThe `TableSelectionSingle` component is a feature designed exclusively for use within the `Table` component.\nIt must be placed inside the `features` slot of `Table`.\nThis component is not intended for standalone use.\n\n```html\n<Table>\n\t<TableSelectionSingle slot=\"features\" selected=\"Row1\"></TableSelectionSingle>\n</Table>\n```\n\n\n\n__Note:__ This is a UI5 Web Component! [TableSelectionSingle UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableSelectionSingle) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableSelectionSingleDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the selection is changed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "behavior": {
+          "type": {
+            "name": "enum",
+            "raw": "TableSelectionBehavior | \"RowSelector\" | \"RowOnly\"",
+            "value": [
+              {
+                "value": "\"RowSelector\"",
+                "description": "Rows can only be selected by using the row selector column."
+              },
+              {
+                "value": "\"RowOnly\"",
+                "description": "Rows can only be selected by clicking directly on the row, as the row selector column is hidden.\n\n**Note:** In this mode, the `row-click` event of the `ui5-table` component is not fired."
+              },
+              {
+                "value": "\"RowSelector\""
+              },
+              {
+                "value": "\"RowOnly\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the selection behavior.\n\n**Note:** Available since [v2.11](https://github.com/UI5/webcomponents/releases/tag/v2.11) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"RowSelector\""
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `row-key` value of the selected row."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableSelectionSingleDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "getRowByKey",
+          "description": "Returns the table row instance for the given row key.",
+          "params": [
+            {
+              "name": "rowKey",
+              "type": {
+                "name": "string"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "TableRow | undefined"
+          }
+        },
+        {
+          "name": "getSelectedRow",
+          "description": "Returns the selected row.",
+          "params": [],
+          "returns": {
+            "type": "TableRow | undefined"
+          }
+        }
+      ]
+    },
+    "TableVirtualizer": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TableVirtualizer` component is used inside the `Table` to virtualize the table rows, if the `overflowMode` property of the table is set to 'Scroll'.\nIt is responsible for rendering only the rows that are visible in the viewport and updating them on scroll.\nThis allows large numbers of rows to exist, but maintain high performance by only paying the cost for those that are currently visible.\n\n**Note:** The maximum number of virtualized rows is limited by browser constraints, specifically the maximum supported height for a DOM element.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableVirtualizer UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableVirtualizer) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onRangeChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TableVirtualizerDomRef, RangeChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the virtualizer is changed by user interaction e.g. on scrolling.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "first",
+                "type": "number",
+                "description": "The 0-based index of the first children currently rendered"
+              },
+              {
+                "name": "last",
+                "type": "number",
+                "description": "The 0-based index of the last children currently rendered"
+              }
+            ],
+            "cancelable": false,
+            "bubbles": false
+          }
+        },
+        "extraRows": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the count of extra rows to be rendered at the top and bottom of the table.\n\n**Note:** This property is experimental and may be changed or deleted in the future.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "rowCount": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the total count of rows in the table.\n\n**Note:** For virtualization to work properly, this property is mandatory.",
+          "defaultValue": {
+            "value": "100"
+          }
+        },
+        "rowHeight": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the height of the rows in the table.\n\n**Note:** For virtualization to work properly, this property is mandatory.",
+          "defaultValue": {
+            "value": "45"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TableVirtualizerDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "reset",
+          "description": "Resets the virtualizer to its initial state and triggers the `range-change` event.",
+          "params": [],
+          "returns": {
+            "type": "void"
+          }
+        }
+      ]
+    },
+    "Tag": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Tag` is a component which serves\nthe purpose to attract the user attention to some piece\nof information (state, quantity, condition, etc.).\nIt can contain icon and text information, and its design can be chosen from specific design types.\n\n### Usage Guidelines\n\n- If the text is longer than the width of the component, it can wrap, or it can show ellipsis, depending on the `wrappingType` property.\n- Colors can be semantic or not semantic.\n\n\n\n__Note:__ This is a UI5 Web Component! [Tag UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Tag) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "icon": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed in the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TagDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on an interactive tag.\n\n**Note:** The event will be fired if the `interactive` property is `true`\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "colorScheme": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the color scheme of the component.\nThere are 10 predefined schemes.\nTo use one you can set a number from `\"1\"` to `\"10\"`. The `colorScheme` `\"1\"` will be set by default.",
+          "defaultValue": {
+            "value": "\"1\""
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "TagDesign | \"Set1\" | \"Set2\" | \"Neutral\" | \"Information\" | \"Positive\" | \"Negative\" | \"Critical\"",
+            "value": [
+              {
+                "value": "\"Set1\"",
+                "description": "Set1 of generic indication colors that are intended for industry-specific use cases"
+              },
+              {
+                "value": "\"Set2\"",
+                "description": "Set2 of generic indication colors that are intended for industry-specific use cases"
+              },
+              {
+                "value": "\"Neutral\"",
+                "description": "Neutral design"
+              },
+              {
+                "value": "\"Information\"",
+                "description": "Information design"
+              },
+              {
+                "value": "\"Positive\"",
+                "description": "Positive design"
+              },
+              {
+                "value": "\"Negative\"",
+                "description": "Negative design"
+              },
+              {
+                "value": "\"Critical\"",
+                "description": "Critical design"
+              },
+              {
+                "value": "\"Set1\""
+              },
+              {
+                "value": "\"Set2\""
+              },
+              {
+                "value": "\"Neutral\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Critical\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the design type of the component.\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Neutral\""
+          }
+        },
+        "hideStateIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the default state icon is shown.\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "interactive": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the component is interactive (focusable and pressable).\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "size": {
+          "type": {
+            "name": "enum",
+            "raw": "TagSize | \"S\" | \"L\"",
+            "value": [
+              {
+                "value": "\"S\"",
+                "description": "Small size of the tag"
+              },
+              {
+                "value": "\"L\"",
+                "description": "Large size of the tag"
+              },
+              {
+                "value": "\"S\""
+              },
+              {
+                "value": "\"L\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines predefined size of the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"S\""
+          }
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "WrappingType | \"None\" | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines how the text of a component will be displayed when there is not enough space.\n\n**Note:** For option \"Normal\" the text will wrap and the\nwords will not be broken based on hyphenation.\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Normal\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TagDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "root",
+          "description": "Used to style the root element."
+        }
+      ]
+    },
+    "Text": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Text` component displays text that can be used in any content area of an application.\n\n### Usage\n\n- Use the `Text` if you want to display text inside a form, table, or any other content area.\n- Do not use the `Text` if you need to reference input type of components (use ui5-label).\n\n### Responsive behavior\n\nThe `Text` component is fully adaptive to all screen sizes.\nBy default, the text will wrap when the space is not enough.\nIn addition, the component supports truncation via the `max-lines` property,\nby defining the number of lines the text should wrap before start truncating.\n\n\n\n__Note:__ This is a UI5 Web Component! [Text UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Text) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "emptyIndicatorMode": {
+          "type": {
+            "name": "enum",
+            "raw": "TextEmptyIndicatorMode | \"Off\" | \"On\"",
+            "value": [
+              {
+                "value": "\"Off\"",
+                "description": "Empty indicator is never rendered."
+              },
+              {
+                "value": "\"On\"",
+                "description": "Empty indicator is rendered always when the component's content is empty."
+              },
+              {
+                "value": "\"Off\""
+              },
+              {
+                "value": "\"On\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Specifies if an empty indicator should be displayed when there is no text.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Off\""
+          }
+        },
+        "maxLines": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the number of lines the text should wrap before it truncates.",
+          "defaultValue": {
+            "value": "Infinity"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TextDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TextArea": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TextArea` component is used to enter multiple rows of text.\n\nWhen empty, it can hold a placeholder similar to a `Input`.\nYou can define the rows of the `TextArea` and also determine specific behavior when handling long texts.\n\n\n\n__Note:__ This is a UI5 Web Component! [TextArea UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TextArea) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed if the component has\n`valueState` of type `Information`, `Critical` or `Negative`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the text has changed and the focus leaves the component.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TextAreaDomRef, TextAreaInputEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the component changes at each keystroke or when\nsomething is pasted.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "escapePressed",
+                "type": "boolean",
+                "description": "Indicates whether the Escape key was pressed, which triggers a revert to the previous value"
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onScroll": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when textarea is scrolled.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSelect": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when some text has been selected.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the textarea.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the textarea."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the user can interact with the component or not.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "growing": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Enables the component to automatically grow and shrink dynamically with its content.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "growingMaxRows": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the maximum number of rows that the component can grow.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "maxlength": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the maximum number of characters that the `value` can have."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint intended to aid the user with data entry when the component has no value."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "rows": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the number of visible text rows for the component.\n\n**Notes:**\n\n- If the `growing` property is enabled, this property defines the minimum rows to be displayed\nin the textarea.\n- The CSS `height` property wins over the `rows` property, if both are set.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "showExceededText": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the characters exceeding the maximum allowed character count are visible\nin the component.\n\nIf set to `false`, the user is not allowed to enter more characters than what is set in the\n`maxlength` property.\nIf set to `true` the characters exceeding the `maxlength` value are selected on\npaste and the counter below the component displays their number.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.\n\n**Note:** If `maxlength` property is set,\nthe component turns into \"Critical\" state once the characters exceeds the limit.\nIn this case, only the \"Negative\" state is considered and can be applied.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TextAreaDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "textarea",
+          "description": "Used to style the native textarea"
+        }
+      ]
+    },
+    "TimePicker": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TimePicker` component provides an input field with assigned clocks which are opened on user action.\nThe `TimePicker` allows users to select a localized time using touch, mouse, or keyboard input.\nIt consists of two parts: the time input field and the clocks.\n\n### Usage\nThe user can enter a time by:\n\n- Using the clocks that are displayed in a popup\n- Typing it in directly in the input field\n\nWhen the user makes an entry and chooses the enter key, the clocks show the corresponding time (hours, minutes and seconds separately).\nWhen the user directly triggers the clocks display, the actual time is displayed.\nFor the `TimePicker`\n\n### Formatting\n\nIf a time is entered by typing it into\nthe input field, it must fit to the used time format.\n\nSupported format options are pattern-based on Unicode LDML Date Format notation.\nFor more information, see [UTS #35: Unicode Locale Data Markup Language](https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table).\n\nFor example, if the `format-pattern` is \"HH:mm:ss\",\na valid value string is \"11:42:35\" and the same is displayed in the input.\n\n### Keyboard handling\n[F4], [Alt]+[Up], [Alt]+[Down] Open/Close picker dialog and move focus to it.\n\nWhen closed:\n\n- [Page Up] - Increments hours by 1. If 12 am is reached, increment hours to 1 pm and vice versa.\n- [Page Down] - Decrements the corresponding field by 1. If 1 pm is reached, decrement hours to 12 am and vice versa.\n- [Shift]+[Page Up] - Increments minutes by 1.\n- [Shift]+[Page Down] - Decrements minutes by 1.\n- [Shift]+[Ctrl]+[Page Up] - Increments seconds by 1.\n- [Shift]+[Ctrl]+[Page Down] - Decrements seconds by 1.\n-\n\nWhen opened:\n\n- [Page Up] - Increments hours by 1. If 12 am is reached, increment hours to 1 pm and vice versa.\n- [Page Down] - Decrements the corresponding field by 1. If 1 pm is reached, decrement hours to 12 am and vice versa.\n- [Shift]+[Page Up] - Increments minutes by 1.\n- [Shift]+[Page Down] - Decrements minutes by 1.\n- [Shift]+[Ctrl]+[Page Up] - Increments seconds by 1.\n- [Shift]+[Ctrl]+[Page Down] - Decrements seconds by 1.\n- [A] or [P] - Selects AM or PM respectively.\n- [0]-[9] - Allows direct time selecting (hours/minutes/seconds).\n- [:] - Allows switching between hours/minutes/seconds clocks. If the last clock is displayed and [:] is pressed, the first clock is beind displayed.\n\n\n\n__Note:__ This is a UI5 Web Component! [TimePicker UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TimePicker) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the `TimePicker`.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the `TimePicker` is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TimePickerDomRef, TimePickerChangeInputEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by clicking the \"OK\" button or\nwhen the text in the input field has changed and the focus leaves the input field.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in correct format pattern and in valid range."
+              },
+              {
+                "name": "value",
+                "type": "string",
+                "description": "The submitted value."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TimePickerDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the value-help dialog of the component is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TimePickerDomRef, TimePickerChangeInputEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the `TimePicker` is changed at each key stroke.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "valid",
+                "type": "boolean",
+                "description": "Indicator if the value is in correct format pattern and in valid range."
+              },
+              {
+                "name": "value",
+                "type": "string",
+                "description": "The current value."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TimePickerDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the value-help dialog of the component is opened.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the aria-label attribute for the component.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id (or many ids) of the elements that label the component.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the disabled state of the comonent.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "formatPattern": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the format, displayed in the input field.\n\nExample:\nHH:mm:ss -> 11:42:35\nhh:mm:ss a -> 2:23:15 PM\nmm:ss -> 12:04 (only minutes and seconds)"
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the open or closed state of the popover.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint, intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** When no placeholder is set, the format pattern is displayed as a placeholder.\nPassing an empty string as the value of this property will make the component appear empty - without placeholder or format pattern."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the readonly state of the comonent.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a formatted time value."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TimePickerDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "formatValue",
+          "description": "Currently selected time represented as JavaScript Date instance / readonly dateValue: Date | null; /** Formats a Java Script date object into a string representing a locale date and time according to the `formatPattern` property of the TimePicker instance",
+          "params": [
+            {
+              "name": "date",
+              "type": {
+                "name": "Date"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "string"
+          }
+        },
+        {
+          "name": "isValid",
+          "description": "Checks if a value is valid against the current `formatPattern` value. **Note:** an empty string is considered as valid value.",
+          "params": [
+            {
+              "name": "value",
+              "type": {
+                "name": "string | undefined"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "boolean"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "input",
+          "description": "Used to style the input element. This part is forwarded to the underlying ui5-input element."
+        }
+      ]
+    },
+    "Timeline": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Timeline` component shows entries (such as objects, events, or posts) in chronological order.\nA common use case is to provide information about changes to an object, or events related to an object.\nThese entries can be generated by the system (for example, value XY changed from A to B), or added manually.\nThere are two distinct variants of the timeline: basic and social. The basic timeline is read-only,\nwhile the social timeline offers a high level of interaction and collaboration, and is integrated within SAP Jam.\n\n__Note:__ This is a UI5 Web Component! [Timeline UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/Timeline) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Determines the content of the `Timeline`.\n\n__Supported Node Type/s:__ `Array<ITimelineItem>`"
+        },
+        "onLoadMore": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TimelineDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user presses the `More` button or scrolls to the Timeline's end.\n\n**Note:** The event will be fired if `growing` is set to `Button` or `Scroll`.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents-fiori**."
+        },
+        "growing": {
+          "type": {
+            "name": "enum",
+            "raw": "TimelineGrowingMode | \"Button\" | \"Scroll\" | \"None\"",
+            "value": [
+              {
+                "value": "\"Button\"",
+                "description": "Event `load-more` is fired\nupon pressing a \"More\" button at the end."
+              },
+              {
+                "value": "\"Scroll\"",
+                "description": "Event `load-more` is fired upon scroll."
+              },
+              {
+                "value": "\"None\"",
+                "description": "The growing feature is not enabled."
+              },
+              {
+                "value": "\"Button\""
+              },
+              {
+                "value": "\"Scroll\""
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines whether the Timeline will have growing capability either by pressing a \"More\" button,\nor via user scroll. In both cases a `load-more` event is fired.\n\nAvailable options:\n\n`Button` - Displays a button at the end of the Timeline, which when pressed triggers the `load-more` event.\n\n`Scroll` -Triggers the `load-more` event when the user scrolls to the end of the Timeline.\n\n`None` (default) - The growing functionality is off.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "layout": {
+          "type": {
+            "name": "enum",
+            "raw": "TimelineLayout | \"Vertical\" | \"Horizontal\"",
+            "value": [
+              {
+                "value": "\"Vertical\"",
+                "description": "Vertical layout\nDefault type"
+              },
+              {
+                "value": "\"Horizontal\"",
+                "description": "Horizontal layout"
+              },
+              {
+                "value": "\"Vertical\""
+              },
+              {
+                "value": "\"Horizontal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the items orientation.",
+          "defaultValue": {
+            "value": "\"Vertical\""
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the component should display a loading indicator over the Timeline.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the loading indicator will show up for this component.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TimelineDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TimelineGroupItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "An entry posted on the timeline.\nIt is intented to represent a group of `<TimelineItem>`s.\n\n**Note**: Please do not use empty groups in order to preserve the intended design.\n\n__Note:__ This is a UI5 Web Component! [TimelineGroupItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/TimelineGroupItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Determines the content of the `TimelineGroupItem`.\n\n__Supported Node Type/s:__ `Array<ITimelineItem>`"
+        },
+        "onToggle": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TimelineGroupItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the group item is expanded or collapsed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "collapsed": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines if the group is collapsed or expanded.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "groupName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the button that expands and collapses the group."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TimelineGroupItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TimelineItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "An entry posted on the timeline.\n\n__Note:__ This is a UI5 Web Component! [TimelineItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/TimelineItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the `TimelineItem`.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "onNameClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TimelineItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the item name is pressed either with a\nclick/tap or by using the Enter or Space key.\n\n**Note:** The event will not be fired if the `name-clickable`\nattribute is not set.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed as graphical element within the `TimelineItem`.\nSAP-icons font provides numerous options.\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the name of the item, displayed before the `title-text`."
+        },
+        "nameClickable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the `name` is clickable.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "state": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the state of the icon displayed in the `TimelineItem`.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "subtitleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the subtitle text of the component."
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the title text of the component."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TimelineItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Title": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Title` component is used to display titles inside a page.\nIt is a simple, large-sized text with explicit header/title semantics.\n\n\n\n__Note:__ This is a UI5 Web Component! [Title UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Title) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\nThis component supports nesting a `Link` component inside.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "level": {
+          "type": {
+            "name": "enum",
+            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
+            "value": [
+              {
+                "value": "\"H1\"",
+                "description": "Renders `h1` tag."
+              },
+              {
+                "value": "\"H2\"",
+                "description": "Renders `h2` tag."
+              },
+              {
+                "value": "\"H3\"",
+                "description": "Renders `h3` tag."
+              },
+              {
+                "value": "\"H4\"",
+                "description": "Renders `h4` tag."
+              },
+              {
+                "value": "\"H5\"",
+                "description": "Renders `h5` tag."
+              },
+              {
+                "value": "\"H6\"",
+                "description": "Renders `h6` tag."
+              },
+              {
+                "value": "\"H1\""
+              },
+              {
+                "value": "\"H2\""
+              },
+              {
+                "value": "\"H3\""
+              },
+              {
+                "value": "\"H4\""
+              },
+              {
+                "value": "\"H5\""
+              },
+              {
+                "value": "\"H6\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component level.\nAvailable options are: `\"H6\"` to `\"H1\"`.\nThis property does not influence the style of the component.\nUse the property `size` for this purpose instead.",
+          "defaultValue": {
+            "value": "\"H2\""
+          }
+        },
+        "size": {
+          "type": {
+            "name": "enum",
+            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
+            "value": [
+              {
+                "value": "\"H1\"",
+                "description": "Renders `h1` tag."
+              },
+              {
+                "value": "\"H2\"",
+                "description": "Renders `h2` tag."
+              },
+              {
+                "value": "\"H3\"",
+                "description": "Renders `h3` tag."
+              },
+              {
+                "value": "\"H4\"",
+                "description": "Renders `h4` tag."
+              },
+              {
+                "value": "\"H5\"",
+                "description": "Renders `h5` tag."
+              },
+              {
+                "value": "\"H6\"",
+                "description": "Renders `h6` tag."
+              },
+              {
+                "value": "\"H1\""
+              },
+              {
+                "value": "\"H2\""
+              },
+              {
+                "value": "\"H3\""
+              },
+              {
+                "value": "\"H4\""
+              },
+              {
+                "value": "\"H5\""
+              },
+              {
+                "value": "\"H6\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the visual appearance of the title.\nAvailable options are: `\"H6\"` to `\"H1\"`.",
+          "defaultValue": {
+            "value": "\"H5\""
+          }
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "WrappingType | \"None\" | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines how the text of a component will be displayed when there is not enough space.\n\n**Note:** for option \"Normal\" the text will wrap and the words will not be broken based on hyphenation.",
+          "defaultValue": {
+            "value": "\"Normal\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TitleDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Toast": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Toast` is a small, non-disruptive popup for success or information messages that\ndisappears automatically after a few seconds.\n\n### Usage\n\n#### When to use:\n\n- You want to display a short success or information message.\n- You do not want to interrupt users while they are performing an action.\n- You want to confirm a successful action.\n\n#### When not to use:\n\n- You want to display error or warning message.\n- You want to interrupt users while they are performing an action.\n- You want to make sure that users read the message before they leave the page.\n- You want users to be able to copy some part of the message text.\n\n\n\n__Note:__ This is a UI5 Web Component! [Toast UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Toast) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ToastDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component is auto closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "duration": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the duration in milliseconds for which component\nremains on the screen before it's automatically closed.\n\n**Note:** The minimum supported value is `500` ms\nand even if a lower value is set, the duration would remain `500` ms.",
+          "defaultValue": {
+            "value": "3000"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the component is open (visible).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placement": {
+          "type": {
+            "name": "enum",
+            "raw": "ToastPlacement | \"TopStart\" | \"TopCenter\" | \"TopEnd\" | \"MiddleStart\" | \"MiddleCenter\" | \"MiddleEnd\" | \"BottomStart\" | \"BottomCenter\" | \"BottomEnd\"",
+            "value": [
+              {
+                "value": "\"TopStart\"",
+                "description": "Toast is placed at the `TopStart` position of its container."
+              },
+              {
+                "value": "\"TopCenter\"",
+                "description": "Toast is placed at the `TopCenter` position of its container."
+              },
+              {
+                "value": "\"TopEnd\"",
+                "description": "Toast is placed at the `TopEnd` position of its container."
+              },
+              {
+                "value": "\"MiddleStart\"",
+                "description": "Toast is placed at the `MiddleStart` position of its container."
+              },
+              {
+                "value": "\"MiddleCenter\"",
+                "description": "Toast is placed at the `MiddleCenter` position of its container."
+              },
+              {
+                "value": "\"MiddleEnd\"",
+                "description": "Toast is placed at the `MiddleEnd` position of its container."
+              },
+              {
+                "value": "\"BottomStart\"",
+                "description": "Toast is placed at the `BottomStart` position of its container."
+              },
+              {
+                "value": "\"BottomCenter\"",
+                "description": "Toast is placed at the `BottomCenter` position of its container.\nDefault placement (no selection)"
+              },
+              {
+                "value": "\"BottomEnd\"",
+                "description": "Toast is placed at the `BottomEnd` position of its container."
+              },
+              {
+                "value": "\"TopStart\""
+              },
+              {
+                "value": "\"TopCenter\""
+              },
+              {
+                "value": "\"TopEnd\""
+              },
+              {
+                "value": "\"MiddleStart\""
+              },
+              {
+                "value": "\"MiddleCenter\""
+              },
+              {
+                "value": "\"MiddleEnd\""
+              },
+              {
+                "value": "\"BottomStart\""
+              },
+              {
+                "value": "\"BottomCenter\""
+              },
+              {
+                "value": "\"BottomEnd\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the placement of the component.",
+          "defaultValue": {
+            "value": "\"BottomCenter\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ToastDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ToggleButton": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ToggleButton` component is an enhanced `Button`\nthat can be toggled between pressed and normal states.\nUsers can use the `ToggleButton` as a switch to turn a setting on or off.\nIt can also be used to represent an independent choice similar to a check box.\n\nClicking or tapping on a `ToggleButton` changes its state to `pressed`. The button returns to\nits initial state when the user clicks or taps on it again.\nBy applying additional custom CSS-styling classes, apps can give a different style to any `ToggleButton`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ToggleButton UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToggleButton) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "badge": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Adds a badge to the button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"badge\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<ButtonBadge>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ToggleButtonDomRef, ButtonClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is activated either with a mouse/tap or by using the Enter or Space key.\n\n**Note:** The event will not be fired if the `disabled` property is set to `true`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "altKey",
+                "type": "boolean",
+                "description": "Returns whether the \"ALT\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "ctrlKey",
+                "type": "boolean",
+                "description": "Returns whether the \"CTRL\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "metaKey",
+                "type": "boolean",
+                "description": "Returns whether the \"META\" key was pressed when the event was triggered."
+              },
+              {
+                "name": "originalEvent",
+                "type": "Event",
+                "description": "Returns original event that comes from user's **click** interaction"
+              },
+              {
+                "name": "shiftKey",
+                "type": "boolean",
+                "description": "Returns whether the \"SHIFT\" key was pressed when the event was triggered."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ButtonAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls, is currently expanded or collapsed.\nAccepts the following string values: `true` or `false`\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n- **ariaLabel**: Defines the accessible ARIA name of the component.\nAccepts any string value.\n\n - **ariaKeyShortcuts**: Defines keyboard shortcuts that activate or give focus to the button.\n\n- **controls**: Identifies the element (or elements) whose contents or presence are controlled by the button element.\nAccepts a lowercase string value.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
+        },
+        "accessibleRole": {
+          "type": {
+            "name": "enum",
+            "raw": "ButtonAccessibleRole | \"Button\" | \"Link\"",
+            "value": [
+              {
+                "value": "\"Button\"",
+                "description": "Represents Default (button) ARIA role."
+              },
+              {
+                "value": "\"Link\"",
+                "description": "Represents the ARIA role \"link\"."
+              },
+              {
+                "value": "\"Button\""
+              },
+              {
+                "value": "\"Link\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Describes the accessibility role of the button.\n\n**Note:** Use <code>ButtonAccessibleRole.Link</code> role only with a press handler, which performs a navigation. In all other scenarios the default button semantics are recommended.\n\n**Note:** Available since [v1.23](https://github.com/UI5/webcomponents/releases/tag/v1.23) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Button\""
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "ButtonDesign | \"Default\" | \"Positive\" | \"Negative\" | \"Transparent\" | \"Emphasized\" | \"Attention\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "default type (no special styling)"
+              },
+              {
+                "value": "\"Positive\"",
+                "description": "accept type (green button)"
+              },
+              {
+                "value": "\"Negative\"",
+                "description": "reject style (red button)"
+              },
+              {
+                "value": "\"Transparent\"",
+                "description": "transparent type"
+              },
+              {
+                "value": "\"Emphasized\"",
+                "description": "emphasized type"
+              },
+              {
+                "value": "\"Attention\"",
+                "description": "attention type"
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Transparent\""
+              },
+              {
+                "value": "\"Emphasized\""
+              },
+              {
+                "value": "\"Attention\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component design.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "endIcon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon, displayed as graphical element within the component after the button text.\n\n**Note:** It is highly recommended to use `endIcon` property only together with `icon` and/or `text` properties.\nUsage of `endIcon` only should be avoided.\n\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon, displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the button shows a loading indicator.\n\n**Note:** If set to `true`, a busy indicator component will be displayed on the related button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Specifies the delay in milliseconds before the loading indicator appears within the associated button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "pressed": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the component is displayed as pressed.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "submits": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "When set to `true`, the component will\nautomatically submit the nearest HTML form element on `press`.\n\n**Note:** This property is only applicable within the context of an HTML Form element.`\n@deprecated Set the \"type\" property to \"Submit\" to achieve the same result. The \"submits\" property is ignored if \"type\" is set to any value other than \"Button\".",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\n**Note:** A tooltip attribute should be provided for icon-only buttons, in order to represent their exact meaning/function.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Button\" | ButtonType | \"Submit\" | \"Reset\"",
+            "value": [
+              {
+                "value": "\"Button\""
+              },
+              {
+                "value": "\"Button\"",
+                "description": "The button does not do anything special when inside a form"
+              },
+              {
+                "value": "\"Submit\"",
+                "description": "The button acts as a submit button (submits a form)"
+              },
+              {
+                "value": "\"Reset\"",
+                "description": "The button acts as a reset button (resets a form)"
+              },
+              {
+                "value": "\"Submit\""
+              },
+              {
+                "value": "\"Reset\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines whether the button has special form-related functionality.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Button\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ToggleButtonDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "button",
+          "description": "Used to style the native button element"
+        },
+        {
+          "name": "endIcon",
+          "description": "Used to style the end icon in the native button element"
+        },
+        {
+          "name": "icon",
+          "description": "Used to style the icon in the native button element"
+        }
+      ]
+    },
+    "Token": {
+      "package": "@ui5/webcomponents-react",
+      "description": "Tokens are small items of information (similar to tags) that mainly serve to visualize previously selected items.\n\n\n\n__Note:__ This is a UI5 Web Component! [Token UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Token) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "closeIcon": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the close icon for the token. If nothing is provided to this slot, the default close icon will be used.\nAccepts `Icon`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"closeIcon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is selected or not.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the token."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TokenDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Tokenizer": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A `Tokenizer` is an invisible container for `Token`s that supports keyboard navigation and token selection.\n\nThe `Tokenizer` consists of two parts:\n- Tokens - displays the available tokens.\n- N-more indicator - contains the number of the remaining tokens that cannot be displayed due to the limited space.\n\n### Keyboard Handling\n\n#### Basic Navigation\nThe `Tokenizer` provides advanced keyboard handling.\nWhen a token is focused the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Left] or [Right] / [Up] or [Down] - Navigates left and right through the tokens.\n- [Home] - Navigates to the first token.\n- [End] - Navigates to the last token.\n\nThe user can use the following keyboard shortcuts to perform actions (such as select, delete):\n\n- [Space] - Selects a token.\n- [Backspace] / [Delete] - Deletes a token.\n**Note:** The deletion of a token is handled by the application with the use of the `token-delete` event.\n\n\n\n__Note:__ This is a UI5 Web Component! [Tokenizer UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Tokenizer) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the tokens to be displayed.\n\n__Supported Node Type/s:__ `Array<Token>`"
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TokenizerDomRef, TokenizerSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when token selection is changed by user interaction\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "tokens",
+                "type": "Array<Token>",
+                "description": "An array of the selected items."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onTokenDelete": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TokenizerDomRef, TokenizerTokenDeleteEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when tokens are being deleted (delete icon, delete or backspace is pressed)\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "tokens",
+                "type": "Array",
+                "description": "An array containing the deleted tokens."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "multiLine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether tokens are displayed on multiple lines.\n\n**Note:** The `multiLine` property is in an experimental state and is a subject to change.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n**Note:** When the component is used inside a form element,\nthe value is sent as the first element in the form data, even if it's empty."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showClearAll": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether \"Clear All\" button is present. Ensure `multiLine` is enabled, otherwise `showClearAll` will have no effect.\n\n**Note:** The `showClearAll` property is in an experimental state and is a subject to change.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TokenizerDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Toolbar": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Toolbar` component is used to create a horizontal layout with items.\nThe items can be overflowing in a popover, when the space is not enough to show all of them.\n\n### Keyboard Handling\nThe `Toolbar` provides advanced keyboard handling.\n\n- The control is not interactive, but can contain of interactive elements\n- [Tab] - iterates through elements\n\n\n\n__Note:__ This is a UI5 Web Component! [Toolbar UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Toolbar) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the component.\n\n**Note:** Currently only `ToolbarButton`, `ToolbarSelect`, `ToolbarSeparator` and `ToolbarSpacer` are allowed here.\n\n__Supported Node Type/s:__ `Array<ToolbarItemBase>`"
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the input."
+        },
+        "alignContent": {
+          "type": {
+            "name": "enum",
+            "raw": "ToolbarAlign | \"Start\" | \"End\"",
+            "value": [
+              {
+                "value": "\"Start\"",
+                "description": "Toolbar items are situated at the `start` of the Toolbar"
+              },
+              {
+                "value": "\"End\"",
+                "description": "Toolbar items are situated at the `end` of the Toolbar"
+              },
+              {
+                "value": "\"Start\""
+              },
+              {
+                "value": "\"End\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Indicated the direction in which the Toolbar items will be aligned.",
+          "defaultValue": {
+            "value": "\"End\""
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "ToolbarDesign | \"Solid\" | \"Transparent\"",
+            "value": [
+              {
+                "value": "\"Solid\"",
+                "description": "The toolbar and its content will be displayed with solid background."
+              },
+              {
+                "value": "\"Transparent\"",
+                "description": "The toolbar and its content will be displayed with transparent background."
+              },
+              {
+                "value": "\"Solid\""
+              },
+              {
+                "value": "\"Transparent\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the toolbar design.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"Solid\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ToolbarDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "isOverflowOpen",
+          "description": "Returns if the overflow popup is open.",
+          "params": [],
+          "returns": {
+            "type": "boolean"
+          }
+        }
+      ]
+    },
+    "ToolbarButton": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ToolbarButton` represents an abstract action,\nused in the `Toolbar`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ToolbarButton UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarButton) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ToolbarButtonDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is activated either with a\nmouse/tap or by using the Enter or Space key.\n\n**Note:** The event will not be fired if the `disabled`\nproperty is set to `true`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ButtonAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\n\nThe following fields are supported:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls, is currently expanded or collapsed.\nAccepts the following string values: `true` or `false`\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n- **controls**: Identifies the element (or elements) whose contents or presence are controlled by the button element.\nAccepts a lowercase string value.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the component."
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "ButtonDesign | \"Default\" | \"Positive\" | \"Negative\" | \"Transparent\" | \"Emphasized\" | \"Attention\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "default type (no special styling)"
+              },
+              {
+                "value": "\"Positive\"",
+                "description": "accept type (green button)"
+              },
+              {
+                "value": "\"Negative\"",
+                "description": "reject style (red button)"
+              },
+              {
+                "value": "\"Transparent\"",
+                "description": "transparent type"
+              },
+              {
+                "value": "\"Emphasized\"",
+                "description": "emphasized type"
+              },
+              {
+                "value": "\"Attention\"",
+                "description": "attention type"
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Transparent\""
+              },
+              {
+                "value": "\"Emphasized\""
+              },
+              {
+                "value": "\"Attention\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the action design.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the action is disabled.\n\n**Note:** a disabled action can't be pressed or focused, and it is not in the tab chain.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "endIcon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon, displayed as graphical element within the component after the button text.\n\n**Note:** It is highly recommended to use `endIcon` property only together with `icon` and/or `text` properties.\nUsage of `endIcon` only should be avoided.\n\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `icon` source URI.\n\n**Note:** SAP-icons font provides numerous buil-in icons. To find all the available icons, see the\n[Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "overflowPriority": {
+          "type": {
+            "name": "enum",
+            "raw": "\"Default\" | ToolbarItemOverflowBehavior | \"NeverOverflow\" | \"AlwaysOverflow\"",
+            "value": [
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Default\"",
+                "description": "The item is presented inside the toolbar and goes in the popover, when there is not enough space."
+              },
+              {
+                "value": "\"NeverOverflow\"",
+                "description": "When set, the item will never go to the overflow popover."
+              },
+              {
+                "value": "\"AlwaysOverflow\"",
+                "description": "When set, the item will be always part of the overflow part of ui5-toolbar."
+              },
+              {
+                "value": "\"NeverOverflow\""
+              },
+              {
+                "value": "\"AlwaysOverflow\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Property used to define the access of the item to the overflow Popover. If \"NeverOverflow\" option is set,\nthe item never goes in the Popover, if \"AlwaysOverflow\" - it never comes out of it.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "preventOverflowClosing": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the toolbar overflow popup should close upon interaction with the item.\nIt will close by default.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showOverflowText": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the button text should only be displayed in the overflow popover.\n\nWhen set to `true`, the button appears as icon-only in the main toolbar,\nbut shows both icon and text when moved to the overflow popover.\n\n**Note:** This property only takes effect when the `text` property is also set.\n\n**Note:** Available since [v2.17.0](https://github.com/UI5/webcomponents/releases/tag/v2.17.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Button text"
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\n**Note:** A tooltip attribute should be provided for icon-only buttons, in order to represent their exact meaning/function."
+        },
+        "width": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the width of the button.\n\n**Note:** all CSS sizes are supported - 'percentage', 'px', 'rem', 'auto', etc."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ToolbarButtonDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ToolbarItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ToolbarItem` is a wrapper component used to integrate UI5 Web Components into the `Toolbar`.\nIt renders within the toolbar's shadow DOM and manages the lifecycle\nand overflow behavior of its child component.\n\n### Structure\nThe toolbar item wraps a single UI5 Web Component (such as CheckBox, Title, etc.) and handles:\n- Overflow management (determining if the item should be displayed in the main toolbar or overflow popover)\n- Automatic popover closing on interaction\n- CSS custom state exposure for styling based on overflow state\n\n### Usage\nThe `ToolbarItem` is typically used implicitly when adding components to a toolbar,\nbut specialized wrappers like `ToolbarButton` provide\ncomponent-specific functionality and should be preferred when available.\n\n__Note:__ This is a UI5 Web Component! [ToolbarItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Wrapped component slot.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IToolbarItemContent>`"
+        },
+        "overflowPriority": {
+          "type": {
+            "name": "enum",
+            "raw": "ToolbarItemOverflowBehavior | \"Default\" | \"NeverOverflow\" | \"AlwaysOverflow\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "The item is presented inside the toolbar and goes in the popover, when there is not enough space."
+              },
+              {
+                "value": "\"NeverOverflow\"",
+                "description": "When set, the item will never go to the overflow popover."
+              },
+              {
+                "value": "\"AlwaysOverflow\"",
+                "description": "When set, the item will be always part of the overflow part of ui5-toolbar."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"NeverOverflow\""
+              },
+              {
+                "value": "\"AlwaysOverflow\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Property used to define the access of the item to the overflow Popover. If \"NeverOverflow\" option is set,\nthe item never goes in the Popover, if \"AlwaysOverflow\" - it never comes out of it.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "preventOverflowClosing": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the toolbar overflow popup should close upon interaction with the item.\nIt will close by default.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ToolbarItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ToolbarSelect": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ToolbarSelect` component is used to create a toolbar drop-down list.\nThe items inside the `ToolbarSelect` define the available options by using the `ToolbarSelectOption` component.\n\n\n\n`import \"@ui5/webcomponents/dist/ToolbarSelectOption.js\";` (comes with `ToolbarSelect`)\n\n__Note:__ This is a UI5 Web Component! [ToolbarSelect UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarSelect) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the component options.\n\n**Note:** Only one selected option is allowed.\nIf more than one option is defined as selected, the last one would be considered as the selected one.\n\n**Note:** Use the `ToolbarSelectOption` component to define the desired options.\n\n__Supported Node Type/s:__ `Array<ToolbarSelectOption>`"
+        },
+        "label": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the HTML element that will be displayed in the component input part,\nrepresenting the selected option.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"label\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ToolbarSelectDomRef, ToolbarSelectChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the selected option changes.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "selectedOption",
+                "type": "HTMLElement",
+                "description": "the selected option."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ToolbarSelectDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component's dropdown menu closes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ToolbarSelectDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the component's dropdown menu opens.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the select."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "overflowPriority": {
+          "type": {
+            "name": "enum",
+            "raw": "ToolbarItemOverflowBehavior | \"Default\" | \"NeverOverflow\" | \"AlwaysOverflow\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "The item is presented inside the toolbar and goes in the popover, when there is not enough space."
+              },
+              {
+                "value": "\"NeverOverflow\"",
+                "description": "When set, the item will never go to the overflow popover."
+              },
+              {
+                "value": "\"AlwaysOverflow\"",
+                "description": "When set, the item will be always part of the overflow part of ui5-toolbar."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"NeverOverflow\""
+              },
+              {
+                "value": "\"AlwaysOverflow\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Property used to define the access of the item to the overflow Popover. If \"NeverOverflow\" option is set,\nthe item never goes in the Popover, if \"AlwaysOverflow\" - it never comes out of it.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "preventOverflowClosing": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the toolbar overflow popup should close upon interaction with the item.\nIt will close by default.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component:\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "width": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the width of the select.\n\n**Note:** all CSS sizes are supported - 'percentage', 'px', 'rem', 'auto', etc."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ToolbarSelectDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ToolbarSelectOption": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ToolbarSelectOption` component defines the content of an option in the `ToolbarSelect`.\n\n__Note:__ This is a UI5 Web Component! [ToolbarSelectOption UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarSelectOption) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ToolbarSelectOptionDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ToolbarSeparator": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ToolbarSeparator` is an element, used for visual separation between two elements.\nIt takes no space in calculating toolbar items width.\n\n__Note:__ This is a UI5 Web Component! [ToolbarSeparator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarSeparator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "overflowPriority": {
+          "type": {
+            "name": "enum",
+            "raw": "ToolbarItemOverflowBehavior | \"Default\" | \"NeverOverflow\" | \"AlwaysOverflow\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "The item is presented inside the toolbar and goes in the popover, when there is not enough space."
+              },
+              {
+                "value": "\"NeverOverflow\"",
+                "description": "When set, the item will never go to the overflow popover."
+              },
+              {
+                "value": "\"AlwaysOverflow\"",
+                "description": "When set, the item will be always part of the overflow part of ui5-toolbar."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"NeverOverflow\""
+              },
+              {
+                "value": "\"AlwaysOverflow\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Property used to define the access of the item to the overflow Popover. If \"NeverOverflow\" option is set,\nthe item never goes in the Popover, if \"AlwaysOverflow\" - it never comes out of it.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "preventOverflowClosing": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the toolbar overflow popup should close upon interaction with the item.\nIt will close by default.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ToolbarSeparatorDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ToolbarSpacer": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ToolbarSpacer` is an element, used for taking needed space for toolbar items to take 100% width.\nIt takes no space in calculating toolbar items width.\n\n__Note:__ This is a UI5 Web Component! [ToolbarSpacer UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarSpacer) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "overflowPriority": {
+          "type": {
+            "name": "enum",
+            "raw": "ToolbarItemOverflowBehavior | \"Default\" | \"NeverOverflow\" | \"AlwaysOverflow\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "The item is presented inside the toolbar and goes in the popover, when there is not enough space."
+              },
+              {
+                "value": "\"NeverOverflow\"",
+                "description": "When set, the item will never go to the overflow popover."
+              },
+              {
+                "value": "\"AlwaysOverflow\"",
+                "description": "When set, the item will be always part of the overflow part of ui5-toolbar."
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"NeverOverflow\""
+              },
+              {
+                "value": "\"AlwaysOverflow\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Property used to define the access of the item to the overflow Popover. If \"NeverOverflow\" option is set,\nthe item never goes in the Popover, if \"AlwaysOverflow\" - it never comes out of it.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "preventOverflowClosing": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the toolbar overflow popup should close upon interaction with the item.\nIt will close by default.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "width": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the width of the spacer.\n\n**Note:** all CSS sizes are supported - 'percentage', 'px', 'rem', 'auto', etc."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ToolbarSpacerDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Tree": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Tree` component provides a tree structure for displaying data in a hierarchy.\n\n### Usage\n\n#### When to use:\n\n- To display hierarchically structured items.\n- To select one or more items out of a set of hierarchically structured items.\n\n#### When not to use:\n\n- To display items not hierarchically structured. In this case, use the List component.\n- To select one item from a very small number of non-hierarchical items. Select or ComboBox might be more appropriate.\n- The hierarchy turns out to have only two levels. In this case, use List with group items.\n\n### Keyboard Handling\n\nThe `Tree` provides advanced keyboard handling.\nThe user can use the following keyboard shortcuts in order to navigate trough the tree:\n\n- [Up] or [Down] - Navigates up and down the tree items that are currently visible.\n- [Right] - Drills down the tree by expanding the tree nodes.\n- [Left] - Goes up the tree and collapses the tree nodes.\n\nThe user can use the following keyboard shortcuts to perform selection,\nwhen the `selectionMode` property is in use:\n\n- [Space] - Selects the currently focused item upon keyup.\n- [Enter]  - Selects the currently focused item upon keydown.\n\n\n\n`import \"@ui5/webcomponents/dist/TreeItem.js\";`\n\n__Note:__ This is a UI5 Web Component! [Tree UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Tree) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the component. Tree items may have other tree items as children.\n\n**Note:** Use `TreeItem` for the intended design.\n\n__Supported Node Type/s:__ `Array<TreeItemBase>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the component header.\n\n**Note:** When the `header` slot is set, the\n`headerText` property is ignored.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onItemClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeItemEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a tree item is activated.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The clicked item."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onItemDelete": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeItemEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the Delete button of any tree item is pressed.\n\n**Note:** A Delete button is displayed on each item,\nwhen the component `selectionMode` property is set to `Delete`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "the deleted item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onItemMouseout": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeItemEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the mouse cursor leaves the tree item borders.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "the hovered item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onItemMouseover": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeItemEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the mouse cursor enters the tree item borders.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "the hovered item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onItemToggle": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeItemEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a tree item is expanded or collapsed.\n\n**Note:** You can call `preventDefault()` on the event object to suppress the event, if needed.\nThis may be handy for example if you want to dynamically load tree items upon the user expanding a node.\nEven if you prevented the event's default behavior, you can always manually call `toggle()` on a tree item.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "the toggled item."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onMove": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable tree item is moved over a potential drop target during a drag-and-drop operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under the `element` property."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMoveOver": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable tree item is dropped onto a drop target.\n\n**Note:** The `move` event is fired only if there was a preceding `move-over` event with prevented default action.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under the `element` property."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when selection is changed by user interaction\nin `Single`, `SingleStart`, `SingleEnd` and `Multiple` modes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "previouslySelectedItems",
+                "type": "Array",
+                "description": "An array of the previously selected items."
+              },
+              {
+                "name": "selectedItems",
+                "type": "Array",
+                "description": "An array of the selected items."
+              },
+              {
+                "name": "targetItem",
+                "type": "HTMLElement",
+                "description": "The item triggering the event."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that describe the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents**."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents**."
+        },
+        "footerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the component footer text."
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the component header text.\n\n**Note:** If the `header` slot is set, this property is ignored."
+        },
+        "noDataText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text that is displayed when the component contains no items."
+        },
+        "selectionMode": {
+          "type": {
+            "name": "enum",
+            "raw": "ListSelectionMode | \"None\" | \"Single\" | \"SingleStart\" | \"SingleEnd\" | \"SingleAuto\" | \"Multiple\" | \"Delete\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "Default mode (no selection)."
+              },
+              {
+                "value": "\"Single\"",
+                "description": "Right-positioned single selection mode (only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleStart\"",
+                "description": "Left-positioned single selection mode (only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleEnd\"",
+                "description": "Selected item is highlighted but no selection element is visible\n(only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleAuto\"",
+                "description": "Selected item is highlighted and selection is changed upon arrow navigation\n(only one list item can be selected - this is always the focused item)."
+              },
+              {
+                "value": "\"Multiple\"",
+                "description": "Multi selection mode (more than one list item can be selected)."
+              },
+              {
+                "value": "\"Delete\"",
+                "description": "Delete mode (only one list item can be deleted via provided delete button)"
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Single\""
+              },
+              {
+                "value": "\"SingleStart\""
+              },
+              {
+                "value": "\"SingleEnd\""
+              },
+              {
+                "value": "\"SingleAuto\""
+              },
+              {
+                "value": "\"Multiple\""
+              },
+              {
+                "value": "\"Delete\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the selection mode of the component. Since the tree uses a `List` to display its structure,\nthe tree modes are exactly the same as the list modes, and are all applicable.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TreeDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "walk",
+          "description": "Perform Depth-First-Search walk on the tree and run a callback on each node",
+          "params": [
+            {
+              "name": "callback",
+              "type": {
+                "name": "WalkCallback"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "void"
+          }
+        }
+      ]
+    },
+    "TreeItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TreeItem` represents a node in a tree structure, shown as a `List`.\n\nThis is the item to use inside a `Tree`.\nYou can represent an arbitrary tree structure by recursively nesting tree items.\n\n\n\n__Note:__ This is a UI5 Web Component! [TreeItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TreeItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the component.\n\n**Note:** Use `TreeItem` or `TreeItemCustom`\n\n__Supported Node Type/s:__ `Array<TreeItemBase>`"
+        },
+        "deleteButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `Button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "image": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "**Note:** While the slot allows option for setting custom avatar, to match the\ndesign guidelines, please use the `Avatar` with size XS.\n\n**Note:** If bigger `Avatar` needs to be used, then the size of the\n`TreeItem` should be customized in order to fit.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"image\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onDetailClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TreeItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ListItemAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents**."
+        },
+        "additionalText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `additionalText`, displayed in the end of the tree item."
+        },
+        "additionalTextState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the state of the `additionalText`.\n\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "expanded": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the tree list item will show a collapse or expand icon inside its toggle button.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hasChildren": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the tree node has children, even if currently no other tree nodes are slotted inside.\n\n**Note:** This property is useful for showing big tree structures where not all nodes are initially loaded due to performance reasons.\nSet this to `true` for nodes you intend to load lazily, when the user clicks the expand button.\nIt is not necessary to set this property otherwise. If a tree item has children, the expand button will be displayed anyway.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "highlight": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\" | Highlight",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "If set, an icon will be displayed before the text of the tree list item."
+        },
+        "indeterminate": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the selection of a tree node is displayed as partially selected.\n\n**Note:** The indeterminate state can be set only programmatically and can’t be achieved by user\ninteraction, meaning that the resulting visual state depends on the values of the `indeterminate`\nand `selected` properties:\n\n-  If a tree node has both `selected` and `indeterminate` set to `true`, it is displayed as partially selected.\n-  If a tree node has `selected` set to `true` and `indeterminate` set to `false`, it is displayed as selected.\n-  If a tree node has `selected` set to `false`, it is displayed as not selected regardless of the value of the `indeterminate` property.\n\n**Note:** This property takes effect only when the `Tree` is in `Multiple` mode.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "movable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the item is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "navigated": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tree item."
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
+            "value": [
+              {
+                "value": "\"Inactive\"",
+                "description": "Indicates the list item does not have any active feedback when item is pressed."
+              },
+              {
+                "value": "\"Active\"",
+                "description": "Indicates that the item is clickable via active feedback when item is pressed."
+              },
+              {
+                "value": "\"Detail\"",
+                "description": "Enables detail button of the list item that fires detail-click event."
+              },
+              {
+                "value": "\"Navigation\"",
+                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
+              },
+              {
+                "value": "\"Inactive\""
+              },
+              {
+                "value": "\"Active\""
+              },
+              {
+                "value": "\"Detail\""
+              },
+              {
+                "value": "\"Navigation\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
+          "defaultValue": {
+            "value": "\"Active\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TreeItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "toggle",
+          "description": "Call this method to manually switch the `expanded` state of a tree item.",
+          "params": [],
+          "returns": {
+            "type": "void"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "additionalText",
+          "description": "Used to style the additionalText of the tree list item"
+        },
+        {
+          "name": "icon",
+          "description": "Used to style the icon of the tree list item"
+        },
+        {
+          "name": "title",
+          "description": "Used to style the title of the tree list item"
+        }
+      ]
+    },
+    "TreeItemCustom": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `TreeItemCustom` represents a node in a tree structure, shown as a `List`.\n\nThis is the item to use inside a `Tree`.\nYou can represent an arbitrary tree structure by recursively nesting tree items.\n\nYou can use this item to put any custom content inside the tree item.\n\n\n\n__Note:__ This is a UI5 Web Component! [TreeItemCustom UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TreeItemCustom) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the component.\n\n**Note:** Use `TreeItem` or `TreeItemCustom`\n\n__Supported Node Type/s:__ `Array<TreeItemBase>`"
+        },
+        "content": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the content of the `TreeItem`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"content\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "deleteButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `Button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "image": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "**Note:** While the slot allows option for setting custom avatar, to match the\ndesign guidelines, please use the `Avatar` with size XS.\n\n**Note:** If bigger `Avatar` needs to be used, then the size of the\n`TreeItem` should be customized in order to fit.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"image\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onDetailClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TreeItemCustomDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ListItemAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents**."
+        },
+        "additionalTextState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the state of the `additionalText`.\n\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "expanded": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the tree list item will show a collapse or expand icon inside its toggle button.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hasChildren": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the tree node has children, even if currently no other tree nodes are slotted inside.\n\n**Note:** This property is useful for showing big tree structures where not all nodes are initially loaded due to performance reasons.\nSet this to `true` for nodes you intend to load lazily, when the user clicks the expand button.\nIt is not necessary to set this property otherwise. If a tree item has children, the expand button will be displayed anyway.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideSelectionElement": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the tree list item should display the selection element.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "highlight": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\" | Highlight",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "If set, an icon will be displayed before the text of the tree list item."
+        },
+        "indeterminate": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the selection of a tree node is displayed as partially selected.\n\n**Note:** The indeterminate state can be set only programmatically and can’t be achieved by user\ninteraction, meaning that the resulting visual state depends on the values of the `indeterminate`\nand `selected` properties:\n\n-  If a tree node has both `selected` and `indeterminate` set to `true`, it is displayed as partially selected.\n-  If a tree node has `selected` set to `true` and `indeterminate` set to `false`, it is displayed as selected.\n-  If a tree node has `selected` set to `false`, it is displayed as not selected regardless of the value of the `indeterminate` property.\n\n**Note:** This property takes effect only when the `Tree` is in `Multiple` mode.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "movable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the item is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "navigated": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
+            "value": [
+              {
+                "value": "\"Inactive\"",
+                "description": "Indicates the list item does not have any active feedback when item is pressed."
+              },
+              {
+                "value": "\"Active\"",
+                "description": "Indicates that the item is clickable via active feedback when item is pressed."
+              },
+              {
+                "value": "\"Detail\"",
+                "description": "Enables detail button of the list item that fires detail-click event."
+              },
+              {
+                "value": "\"Navigation\"",
+                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
+              },
+              {
+                "value": "\"Inactive\""
+              },
+              {
+                "value": "\"Active\""
+              },
+              {
+                "value": "\"Detail\""
+              },
+              {
+                "value": "\"Navigation\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
+          "defaultValue": {
+            "value": "\"Active\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TreeItemCustomDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "toggle",
+          "description": "Call this method to manually switch the `expanded` state of a tree item.",
+          "params": [],
+          "returns": {
+            "type": "void"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "additionalText",
+          "description": "Used to style the additionalText of the tree list item"
+        },
+        {
+          "name": "icon",
+          "description": "Used to style the icon of the tree list item"
+        },
+        {
+          "name": "title",
+          "description": "Used to style the title of the tree list item"
+        }
+      ]
+    },
+    "UploadCollection": {
+      "package": "@ui5/webcomponents-react",
+      "description": "This component allows you to represent files before uploading them to a server, with the help of `UploadCollectionItem`.\nIt also allows you to show already uploaded files.\n\n\n\n`import \"@ui5/webcomponents-fiori/dist/UploadCollectionItem.js\";` (for `UploadCollectionItem`)\n\n__Note:__ This is a UI5 Web Component! [UploadCollection UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UploadCollection) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the `UploadCollection`.\n\n**Note:** Use `UploadCollectionItem` for the intended design.\n\n__Supported Node Type/s:__ `Array<UploadCollectionItem>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the `UploadCollection` header.\n\n**Note:** If `header` slot is provided,\nthe labelling of the `UploadCollection` is a responsibility of the application developer.\n`accessibleName` should be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onItemDelete": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UploadCollectionDomRef, UploadCollectionItemDeleteEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when an element is dropped inside the drag and drop overlay.\n\n**Note:** The `drop` event is fired only when elements are dropped within the drag and drop overlay and ignored for the other parts of the `UploadCollection`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "dataTransfer",
+                "type": "DataTransfer",
+                "description": "The `drop` event operation data."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UploadCollectionDomRef, UploadCollectionSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when selection is changed by user interaction\nin `Single` and `Multiple` modes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "selectedItems",
+                "type": "Array",
+                "description": "An array of the selected items."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "hideDragOverlay": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "By default there will be drag and drop overlay shown over the `UploadCollection` when files\nare dragged. If you don't intend to use drag and drop, set this property.\n\n**Note:** It is up to the application developer to add handler for `drop` event and handle it.\n`UploadCollection` only displays an overlay.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "noDataDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Allows you to set your own text for the 'No data' description."
+        },
+        "noDataHeaderLevel": {
+          "type": {
+            "name": "enum",
+            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
+            "value": [
+              {
+                "value": "\"H1\"",
+                "description": "Renders `h1` tag."
+              },
+              {
+                "value": "\"H2\"",
+                "description": "Renders `h2` tag."
+              },
+              {
+                "value": "\"H3\"",
+                "description": "Renders `h3` tag."
+              },
+              {
+                "value": "\"H4\"",
+                "description": "Renders `h4` tag."
+              },
+              {
+                "value": "\"H5\"",
+                "description": "Renders `h5` tag."
+              },
+              {
+                "value": "\"H6\"",
+                "description": "Renders `h6` tag."
+              },
+              {
+                "value": "\"H1\""
+              },
+              {
+                "value": "\"H2\""
+              },
+              {
+                "value": "\"H3\""
+              },
+              {
+                "value": "\"H4\""
+              },
+              {
+                "value": "\"H5\""
+              },
+              {
+                "value": "\"H6\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the header level of the 'No data' text.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"H2\""
+          }
+        },
+        "noDataText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Allows you to set your own text for the 'No data' text."
+        },
+        "selectionMode": {
+          "type": {
+            "name": "enum",
+            "raw": "UploadCollectionSelectionMode | \"None\" | \"Single\" | \"SingleStart\" | \"SingleEnd\" | \"SingleAuto\" | \"Multiple\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "Default mode (no selection)."
+              },
+              {
+                "value": "\"Single\"",
+                "description": "Right-positioned single selection mode (only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleStart\"",
+                "description": "Left-positioned single selection mode (only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleEnd\"",
+                "description": "Selected item is highlighted but no selection element is visible\n(only one list item can be selected)."
+              },
+              {
+                "value": "\"SingleAuto\"",
+                "description": "Selected item is highlighted and selection is changed upon arrow navigation\n(only one list item can be selected - this is always the focused item)."
+              },
+              {
+                "value": "\"Multiple\"",
+                "description": "Multi selection mode (more than one list item can be selected)."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Single\""
+              },
+              {
+                "value": "\"SingleStart\""
+              },
+              {
+                "value": "\"SingleEnd\""
+              },
+              {
+                "value": "\"SingleAuto\""
+              },
+              {
+                "value": "\"Multiple\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the selection mode of the `UploadCollection`.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UploadCollectionDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "UploadCollectionItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A component to be used within the `UploadCollection`.\n\n\n\n__Note:__ This is a UI5 Web Component! [UploadCollectionItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UploadCollectionItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Hold the description of the `UploadCollectionItem`. Will be shown below the file name.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "deleteButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `ui5-button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "thumbnail": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "A thumbnail, which will be shown in the beginning of the `UploadCollectionItem`.\n\n**Note:** Use `ui5-icon` or `img` for the intended design.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"thumbnail\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onDetailClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UploadCollectionItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onFileNameClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UploadCollectionItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the file name is clicked.\n\n**Note:** This event is only available when `fileNameClickable` property is `true`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onRename": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UploadCollectionItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `fileName` property gets changed.\n\n**Note:** An edit button is displayed on each item,\nwhen the `UploadCollectionItem` `type` property is set to `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onRetry": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UploadCollectionItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the retry button is pressed.\n\n**Note:** Retry button is displayed when `uploadState` property is set to `Error`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onTerminate": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UploadCollectionItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the terminate button is pressed.\n\n**Note:** Terminate button is displayed when `uploadState` property is set to `Uploading`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ListItemAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "disableDeleteButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Disables the delete button.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "file": {
+          "type": {
+            "name": "File"
+          },
+          "required": false,
+          "description": "Holds an instance of `File` associated with this item.",
+          "defaultValue": {
+            "value": "null"
+          }
+        },
+        "fileName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "The name of the file."
+        },
+        "fileNameClickable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "If set to `true` the file name will be clickable and it will fire `file-name-click` event upon click.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideDeleteButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Hides the delete button.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideRetryButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Hides the retry button when `uploadState` property is `Error`.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "hideTerminateButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Hides the terminate button when `uploadState` property is `Uploading`.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "highlight": {
+          "type": {
+            "name": "enum",
+            "raw": "Highlight | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "navigated": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "progress": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The upload progress in percentage.\n\n**Note:** Expected values are in the interval [0, 100].",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents-fiori**."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
+            "value": [
+              {
+                "value": "\"Inactive\"",
+                "description": "Indicates the list item does not have any active feedback when item is pressed."
+              },
+              {
+                "value": "\"Active\"",
+                "description": "Indicates that the item is clickable via active feedback when item is pressed."
+              },
+              {
+                "value": "\"Detail\"",
+                "description": "Enables detail button of the list item that fires detail-click event."
+              },
+              {
+                "value": "\"Navigation\"",
+                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
+              },
+              {
+                "value": "\"Inactive\""
+              },
+              {
+                "value": "\"Active\""
+              },
+              {
+                "value": "\"Detail\""
+              },
+              {
+                "value": "\"Navigation\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
+          "defaultValue": {
+            "value": "\"Active\""
+          }
+        },
+        "uploadState": {
+          "type": {
+            "name": "enum",
+            "raw": "UploadState | \"Complete\" | \"Error\" | \"Ready\" | \"Uploading\"",
+            "value": [
+              {
+                "value": "\"Complete\"",
+                "description": "The file has been uploaded successfully."
+              },
+              {
+                "value": "\"Error\"",
+                "description": "The file cannot be uploaded due to an error."
+              },
+              {
+                "value": "\"Ready\"",
+                "description": "The file is awaiting an explicit command to start being uploaded."
+              },
+              {
+                "value": "\"Uploading\"",
+                "description": "The file is currently being uploaded."
+              },
+              {
+                "value": "\"Complete\""
+              },
+              {
+                "value": "\"Error\""
+              },
+              {
+                "value": "\"Ready\""
+              },
+              {
+                "value": "\"Uploading\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Upload state.\n\nDepending on this property, the item displays the following:\n\n- `Ready` - progress indicator is displayed.\n- `Uploading` - progress indicator and terminate button are displayed. When the terminate button is pressed, `terminate` event is fired.\n- `Error` - progress indicator and retry button are displayed. When the retry button is pressed, `retry` event is fired.\n- `Complete` - progress indicator is not displayed.",
+          "defaultValue": {
+            "value": "\"Ready\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UploadCollectionItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "UserMenu": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `UserMenu` is an SAP Fiori specific web component that is used in `ShellBar`\nand allows the user to easily see information and settings for the current user and all other logged in accounts.\n\n\n\n`import \"@ui5/webcomponents-fiori/dist/UserMenuItem.js\";` (for `UserMenuItem`)\n\n__Note:__ This is a UI5 Web Component! [UserMenu UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserMenu) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "accounts": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the user accounts.\n\n**Note:** If one item is used, it will be shown as the selected one. If more than one item is used, the first one will be shown as selected unless\nthere is an item with `selected` property set to `true`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"accounts\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<UserMenuAccount>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the menu items.\n\n__Supported Node Type/s:__ `Array<UserMenuItem>`"
+        },
+        "footer": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines custom footer content.\n\n**Note:** When provided, replaces the default \"Sign Out\" button. Use an empty element to hide the footer completely.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onAvatarClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the account avatar is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onChangeAccount": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuDomRef, UserMenuOtherAccountClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the account is switched to a different one.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "prevSelectedAccount",
+                "type": "UserMenuAccount",
+                "description": "The previously selected account."
+              },
+              {
+                "name": "selectedAccount",
+                "type": "UserMenuAccount",
+                "description": "The selected account."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when a user menu is close.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onEditAccountsClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the \"Edit Accounts\" button is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onItemClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuDomRef, UserMenuItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a menu item is selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "UserMenuItem",
+                "description": "The selected `user menu item`."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onManageAccountClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the \"Manage Account\" button is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when a user menu is open.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onSignOutClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the \"Sign Out\" button is selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the User Menu is opened.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "opener": {
+          "type": {
+            "name": "string | HTMLElement"
+          },
+          "required": false,
+          "description": "Defines the ID or DOM Reference of the element at which the user menu is shown.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript."
+        },
+        "showEditAccounts": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the User Menu shows the Edit Accounts option.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showEditButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the User menu shows edit button.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showManageAccount": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the User Menu shows the Manage Account option.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showOtherAccounts": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the User Menu shows the Other Accounts option.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UserMenuDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "UserMenuAccount": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `UserMenuAccount` represents an account in the `UserMenu`.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserMenuAccount UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserMenuAccount) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "additionalInfo": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines additional information for the user."
+        },
+        "avatarColorScheme": {
+          "type": {
+            "name": "enum",
+            "raw": "AvatarColorScheme | \"Auto\" | \"Accent1\" | \"Accent2\" | \"Accent3\" | \"Accent4\" | \"Accent5\" | \"Accent6\" | \"Accent7\" | \"Accent8\" | \"Accent9\" | \"Accent10\" | \"Placeholder\" | \"Transparent\"",
+            "value": [
+              {
+                "value": "\"Auto\""
+              },
+              {
+                "value": "\"Accent1\""
+              },
+              {
+                "value": "\"Accent2\""
+              },
+              {
+                "value": "\"Accent3\""
+              },
+              {
+                "value": "\"Accent4\""
+              },
+              {
+                "value": "\"Accent5\""
+              },
+              {
+                "value": "\"Accent6\""
+              },
+              {
+                "value": "\"Accent7\""
+              },
+              {
+                "value": "\"Accent8\""
+              },
+              {
+                "value": "\"Accent9\""
+              },
+              {
+                "value": "\"Accent10\""
+              },
+              {
+                "value": "\"Placeholder\""
+              },
+              {
+                "value": "\"Transparent\""
+              },
+              {
+                "value": "\"Auto\""
+              },
+              {
+                "value": "\"Accent1\""
+              },
+              {
+                "value": "\"Accent2\""
+              },
+              {
+                "value": "\"Accent3\""
+              },
+              {
+                "value": "\"Accent4\""
+              },
+              {
+                "value": "\"Accent5\""
+              },
+              {
+                "value": "\"Accent6\""
+              },
+              {
+                "value": "\"Accent7\""
+              },
+              {
+                "value": "\"Accent8\""
+              },
+              {
+                "value": "\"Accent9\""
+              },
+              {
+                "value": "\"Accent10\""
+              },
+              {
+                "value": "\"Placeholder\""
+              },
+              {
+                "value": "\"Transparent\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the background color of the desired image.\nIf `avatarColorScheme` is set to `Auto`, the avatar will be displayed with the `Accent6` color.",
+          "defaultValue": {
+            "value": "\"Auto\""
+          }
+        },
+        "avatarInitials": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the avatar initials of the user."
+        },
+        "avatarSrc": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the avatar image url of the user."
+        },
+        "description": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines description of the user."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether a loading indicator should be shown.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the user is selected.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "subtitleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines additional text of the user."
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the title text of the user."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UserMenuAccountDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "UserMenuItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "`UserMenuItem` is the item to use inside a `UserMenu`.\nAn arbitrary hierarchy structure can be represented by recursively nesting menu items.\n\n### Usage\n\n`UserMenuItem` represents a node in a `UserMenu`. The user menu itself is rendered as a list,\nand each `ui5-menu-item` is represented by a menu item in that menu. Therefore, you should only use\n`UserMenuItem` directly in your apps. The `ui5-menu` menu item is internal for the menu, and not intended for public use.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserMenuItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserMenuItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of this component.\n\n**Note:** Use `UserMenuItem` for the intended design.\n\n__Supported Node Type/s:__ `Array<UserMenuItem>`"
+        },
+        "deleteButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `ui5-button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "endContent": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the components that should be displayed at the end of the menu item.\n\n**Note:** It is highly recommended to slot only components of type `ui5-button`,`ui5-link`\nor `ui5-icon` in order to preserve the intended design. If there are components added to this slot,\nand there is text set in `additionalText`, it will not be displayed. If there are items added to `items` slot,\nnether `additionalText` nor components added to this slot would be displayed.\n\nThe priority of what will be displayed at the end of the menu item is as follows:\nsub-menu arrow (if there are items added in `items` slot) -> components added in `endContent` -> text set to `additionalText`.\n\nApplication developers are responsible for ensuring that interactive elements placed in the `endContent` slot\nhave the correct accessibility behaviour, including their enabled or disabled states.\nThe menu does not manage these aspects when the menu item state changes.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"endContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onBeforeClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, MenuBeforeCloseEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the menu is closed. This event can be cancelled, which will prevent the menu from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "escPressed",
+                "type": "boolean",
+                "description": "Indicates that `ESC` key has triggered the event."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onBeforeOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, MenuBeforeOpenEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired before the menu is opened. This event can be cancelled, which will prevent the menu from opening.\n\n**Note:** Since 1.14.0 the event is also fired before a sub-menu opens.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The menu item that triggers opening of the sub-menu or undefined when fired upon root menu opening."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onCheck": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when an item is checked or unchecked.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the menu is closed.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onDetailClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the menu is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "MenuItemAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaKeyShortcuts**: Indicated the availability of a keyboard shortcuts defined for the menu item.\n\n- **role**: Defines the role of the menu item. If not set, menu item will have default role=\"menuitem\".\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.7.0](https://github.com/UI5/webcomponents/releases/tag/v1.7.0) of **@ui5/webcomponents-fiori**."
+        },
+        "additionalText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `additionalText`, displayed in the end of the menu item.\n\n**Note:** The additional text will not be displayed if there are items added in `items` slot or there are\ncomponents added to `endContent` slot.\n\nThe priority of what will be displayed at the end of the menu item is as follows:\nsub-menu arrow (if there are items added in `items` slot) -> components added in `endContent` -> text set to `additionalText`.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents-fiori**."
+        },
+        "checked": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether menu item is in checked state.\n\n**Note:** checked state is only taken into account when menu item is added to menu item group\nwith `checkMode` other than `None`.\n\n**Note:** A checked menu item has a checkmark displayed at its end.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether menu item is in disabled state.\n\n**Note:** A disabled menu item is noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "highlight": {
+          "type": {
+            "name": "enum",
+            "raw": "Highlight | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\n**Example:**\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the loading indicator will be displayed inside the corresponding menu popover.\n\n**Note:** If set to `true` a busy indicator component will be displayed into the related one to the current menu item sub-menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the loading indicator will be displayed inside the corresponding menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "navigated": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tree item."
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tooltip for the menu item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents-fiori**."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
+            "value": [
+              {
+                "value": "\"Inactive\"",
+                "description": "Indicates the list item does not have any active feedback when item is pressed."
+              },
+              {
+                "value": "\"Active\"",
+                "description": "Indicates that the item is clickable via active feedback when item is pressed."
+              },
+              {
+                "value": "\"Detail\"",
+                "description": "Enables detail button of the list item that fires detail-click event."
+              },
+              {
+                "value": "\"Navigation\"",
+                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
+              },
+              {
+                "value": "\"Inactive\""
+              },
+              {
+                "value": "\"Active\""
+              },
+              {
+                "value": "\"Detail\""
+              },
+              {
+                "value": "\"Navigation\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
+          "defaultValue": {
+            "value": "\"Active\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UserMenuItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "UserMenuItemGroup": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `UserMenuItemGroup` component represents a group of items designed for use inside a `UserMenu`.\nItems belonging to the same group should be wrapped by a `UserMenuItemGroup`.\nEach group can have an `itemCheckMode` property, which defines the check mode for the items within the group.\nThe possible values for `itemCheckMode` are:\n- 'None' (default) - no items can be checked\n- 'Single' - Only one item can be checked at a time\n- 'Multiple' - Multiple items can be checked simultaneously\n\n**Note:** If the `itemCheckMode` property is set to 'Single', only one item can remain checked at any given time.\nIf multiple items are marked as checked, the last checked item will take precedence.\n\n### Usage\n\n`UserMenuItemGroup` represents a collection of `UserMenuItem` components that can have the same check mode.\nThe items are addeed to the group's `items` slot.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserMenuItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserMenuItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of this component.\n**Note:** The slot can hold any combination of components of type `ui5-menu-item` or `ui5-menu-separator` or both.\n\n__Supported Node Type/s:__ `Array<IMenuItem>`"
+        },
+        "checkMode": {
+          "type": {
+            "name": "enum",
+            "raw": "MenuItemGroupCheckMode | \"None\" | \"Single\" | \"Multiple\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "default type (items in a group cannot be checked)"
+              },
+              {
+                "value": "\"Single\"",
+                "description": "Single item check mode (only one item in a group can be checked at a time)"
+              },
+              {
+                "value": "\"Multiple\"",
+                "description": "Multiple items check mode (multiple items in a group can be checked at a time)"
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Single\""
+              },
+              {
+                "value": "\"Multiple\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component's check mode.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UserMenuItemGroupDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "UserSettingsAccountView": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `UserSettingsAccountView` represents a view displayed in the `UserSettingsItem`.\n\n__Note:__ This is a UI5 Web Component! [UserSettingsAccountView UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsAccountView) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "account": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the user account.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"account\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<UserMenuAccount>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the view.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onEditAccountsClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserSettingsAccountViewDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `Edit Accounts` button is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onManageAccountClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserSettingsAccountViewDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the `Manage Account` button is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "secondary": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the view is secondary. It is relevant only if the view is used in `pages` slot of `UserSettingsItem`\nand controls the visibility of the back button.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the view is selected. There can be just one selected view at a time.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showManageAccount": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the User Menu shows the `Manage Account` option.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the title text of the user settings view."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UserSettingsAccountViewDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "UserSettingsAppearanceView": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `UserSettingsAppearanceView` represents a view displayed in the `UserSettingsItem`.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserSettingsAppearanceView UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsAppearanceView) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "additionalContent": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines additional content displayed below the items list.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"additionalContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the component.\n\n__Supported Node Type/s:__ `Array<UserSettingsAppearanceViewGroup | UserSettingsAppearanceViewItem>`"
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserSettingsAppearanceViewDomRef, UserSettingsAppearanceViewItemSelectEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when an item is selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "UserSettingsAppearanceViewItem",
+                "description": "The selected `user settings appearance view item`."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "secondary": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the view is secondary. It is relevant only if the view is used in `pages` slot of `UserSettingsItem`\nand controls the visibility of the back button.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the view is selected. There can be just one selected view at a time.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the title text of the user settings view."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UserSettingsAppearanceViewDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "UserSettingsAppearanceViewGroup": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `UserSettingsAppearanceViewGroup` is a special list item group used to group appearance view items.\n\nThis is the item to use inside a `UserSettingsAppearanceView`.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserSettingsAppearanceViewGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsAppearanceViewGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the items of the <code>ui5-user-settings-appearance-view-group</code>.\n\n__Supported Node Type/s:__ `Array<UserSettingsAppearanceViewItem>`"
+        },
+        "header": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
+        },
+        "onMove": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserSettingsAppearanceViewGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onMoveOver": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserSettingsAppearanceViewGroupDomRef, ListItemGroupMoveEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "destination",
+                "type": "object",
+                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
+              },
+              {
+                "name": "source",
+                "type": "object",
+                "description": "Contains information about the moved element under `element` property."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "headerAccessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible name of the header."
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the header text of the <code>ui5-li-group</code>."
+        },
+        "wrappingType": {
+          "type": {
+            "name": "enum",
+            "raw": "WrappingType | \"None\" | \"Normal\"",
+            "value": [
+              {
+                "value": "\"None\"",
+                "description": "The text will be truncated with an ellipsis."
+              },
+              {
+                "value": "\"Normal\"",
+                "description": "The text will wrap. The words will not be broken based on hyphenation."
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Normal\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ui5-expandable-text` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UserSettingsAppearanceViewGroupDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "header",
+          "description": "Used to style the header item of the group"
+        },
+        {
+          "name": "title",
+          "description": "Used to style the title of the group header"
+        }
+      ]
+    },
+    "UserSettingsAppearanceViewItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `UserSettingsAppearanceViewItem` represents a theme/appearance option item\nwithin the `UserSettingsAppearanceView`.\n\nIt displays a theme with an avatar icon, text label, and can be selected.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserSettingsAppearanceViewItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsAppearanceViewItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "deleteButton": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `ui5-button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
+        },
+        "onDetailClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserSettingsAppearanceViewItemDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "ListItemAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text alternative of the component.\n\n**Note**: If not provided a default text alternative will be set, if present."
+        },
+        "colorScheme": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the color scheme of the avatar.",
+          "defaultValue": {
+            "value": "\"Accent7\""
+          }
+        },
+        "highlight": {
+          "type": {
+            "name": "enum",
+            "raw": "Highlight | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon of the appearance item.",
+          "defaultValue": {
+            "value": "\"product\""
+          }
+        },
+        "itemKey": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the unique identifier of the item."
+        },
+        "movable": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the item is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "navigated": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the selected state of the component.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text label displayed for the appearance item."
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents-fiori**."
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
+            "value": [
+              {
+                "value": "\"Inactive\"",
+                "description": "Indicates the list item does not have any active feedback when item is pressed."
+              },
+              {
+                "value": "\"Active\"",
+                "description": "Indicates that the item is clickable via active feedback when item is pressed."
+              },
+              {
+                "value": "\"Detail\"",
+                "description": "Enables detail button of the list item that fires detail-click event."
+              },
+              {
+                "value": "\"Navigation\"",
+                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
+              },
+              {
+                "value": "\"Inactive\""
+              },
+              {
+                "value": "\"Active\""
+              },
+              {
+                "value": "\"Detail\""
+              },
+              {
+                "value": "\"Navigation\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
+          "defaultValue": {
+            "value": "\"Active\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UserSettingsAppearanceViewItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "checkbox",
+          "description": "Used to style the checkbox rendered when the list item is in multiple selection mode"
+        },
+        {
+          "name": "content",
+          "description": "Used to style the content area of the list item"
+        },
+        {
+          "name": "delete-button",
+          "description": "Used to style the button rendered when the list item is in delete mode"
+        },
+        {
+          "name": "detail-button",
+          "description": "Used to style the button rendered when the list item is of type detail"
+        },
+        {
+          "name": "native-li",
+          "description": "Used to style the main li tag of the list item"
+        },
+        {
+          "name": "radio",
+          "description": "Used to style the radio button rendered when the list item is in single selection mode"
+        }
+      ]
+    },
+    "UserSettingsDialog": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `UserSettingsDialog` is an SAP Fiori-specific web component used in the `UserMenu`.\nIt allows the user to easily view information and settings for an account.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserSettingsDialog UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsDialog) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the user settings items.\n\n**Note:**  If no setting item is set as `selected`, the first one will be selected.\n\n__Supported Node Type/s:__ `Array<UserSettingsItem>`"
+        },
+        "fixedItems": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the fixed user settings items.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"fixedItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<UserSettingsItem>`"
+        },
+        "onBeforeClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserSettingsDialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired before the settings dialog is closed.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserSettingsDialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when a settings dialog is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserSettingsDialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when a settings dialog is open.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserSettingsDialogDomRef, UserSettingsItemSelectEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when an item is selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "UserSettingsItem",
+                "description": "The selected `user settings item`."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the headerText of the item."
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines, if the User Settings Dialog is opened.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showSearchField": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the Search Field would be displayed.\n\n**Note:** By default the Search Field is not displayed.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UserSettingsDialogDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "UserSettingsItem": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `UserSettingsItem` represents an item in the `UserSettingsDialog`.\n\n\n\nYou can disable the <code>UserSettingsItem</code> by setting the <code>enabled</code> property to <code>false</code>,\nor use the <code>UserSettingsItem</code> in read-only mode by setting the <code>editable</code> property to false.\n\n<b>Note:</b> Disabled and read-only states shouldn't be used together.\n\n__Note:__ This is a UI5 Web Component! [UserSettingsItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the page views of the user settings item.\n\nIf there are no tab views, the first page view will be shown unless there is selected one. If there is selected page\nview it will be shown no matter if there are tab views.\n\nThe page views are displayed by default if there is no selected tab view.\n\n__Supported Node Type/s:__ `Array<UserSettingsView>`"
+        },
+        "tabs": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the tab views of the user settings item.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"tabs\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<UserSettingsView>`"
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<UserSettingsItemDomRef, UserSettingsItemViewSelectEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when a selected view changed.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "view",
+                "type": "UserSettingsView",
+                "description": "The selected `view`."
+              }
+            ],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "headerText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the headerText of the item."
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon of the component.",
+          "defaultValue": {
+            "value": "\"globe\""
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether a loading indicator should be shown.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "loadingReason": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Indicates why the control is in loading state."
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Shows item tab.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the user settings item."
+        },
+        "tooltip": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the tooltip of the component.\n\nA tooltip attribute should be provided to represent the meaning or function when the component is collapsed and only the icon is visible."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UserSettingsItemDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "UserSettingsView": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `UserSettingsView` represents a view displayed in the `UserSettingsItem`.\n\n__Note:__ This is a UI5 Web Component! [UserSettingsView UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsView) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the content of the view.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "secondary": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the view is secondary. It is relevant only if the view is used in `pages` slot of `UserSettingsItem`\nand controls the visibility of the back button.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the view is selected. There can be just one selected view at a time.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the title text of the user settings view."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<UserSettingsViewDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ViewSettingsDialog": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `ViewSettingsDialog` component helps the user to sort data within a list or a table.\nIt consists of several lists like `Sort order` which is built-in and `Sort By` and `Filter By` lists,\nfor which you must be provide items(`SortItem` & `FilterItem` respectively)\nThese options can be used to create sorters for a table.\n\nThe `ViewSettingsDialog` interrupts the current application processing as it is the only focused UI element and\nthe main screen is dimmed/blocked.\nThe `ViewSettingsDialog` is modal, which means that user action is required before returning to the parent window is possible.\n\n### Structure\nA `ViewSettingsDialog` consists of a header, content, and a footer for action buttons.\nThe `ViewSettingsDialog` is usually displayed at the center of the screen.\n\n### Responsive Behavior\n`ViewSettingsDialog` stretches on full screen on phones.\n\n\n\n__Note:__ This is a UI5 Web Component! [ViewSettingsDialog UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ViewSettingsDialog) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "filterItems": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the `filterItems` list.\n\n**Note:** If you want to use this slot, you need to import used item: `import \"@ui5/webcomponents-fiori/dist/FilterItem.js\";`\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"filterItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<FilterItem>`"
+        },
+        "groupItems": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the list of items against which the user could group data.\n\n**Note:** If you want to use this slot, you need to import used item: `import \"@ui5/webcomponents-fiori/dist/GroupItem.js\";`\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"groupItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<GroupItem>`"
+        },
+        "sortItems": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the list of items against which the user could sort data.\n\n**Note:** If you want to use this slot, you need to import used item: `import \"@ui5/webcomponents-fiori/dist/SortItem.js\";`\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"sortItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<SortItem>`"
+        },
+        "onBeforeOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ViewSettingsDialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired before the component is opened.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onCancel": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ViewSettingsDialogDomRef, ViewSettingsDialogCancelEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when cancel button is activated.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "filters",
+                "type": "Array",
+                "description": "The selected filters items."
+              },
+              {
+                "name": "groupBy",
+                "type": "String",
+                "description": "The currently selected `ui5-group-item` text attribute."
+              },
+              {
+                "name": "groupByItem",
+                "type": "HTMLElement",
+                "description": "The currently selected `ui5-group-item`."
+              },
+              {
+                "name": "groupDescending",
+                "type": "Boolean",
+                "description": "The selected group order (true = descending, false = ascending)."
+              },
+              {
+                "name": "groupOrder",
+                "type": "String",
+                "description": "The current group order selected."
+              },
+              {
+                "name": "sortBy",
+                "type": "String",
+                "description": "The currently selected `ui5-sort-item` text attribute."
+              },
+              {
+                "name": "sortByItem",
+                "type": "HTMLElement",
+                "description": "The currently selected `ui5-sort-item`."
+              },
+              {
+                "name": "sortDescending",
+                "type": "Boolean",
+                "description": "The selected sort order (true = descending, false = ascending)."
+              },
+              {
+                "name": "sortOrder",
+                "type": "String",
+                "description": "The current sort order selected."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ViewSettingsDialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the dialog is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onConfirm": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ViewSettingsDialogDomRef, ViewSettingsDialogConfirmEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when confirmation button is activated.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "filters",
+                "type": "Array",
+                "description": "The selected filters items."
+              },
+              {
+                "name": "groupBy",
+                "type": "String",
+                "description": "The currently selected `ui5-group-item` text attribute."
+              },
+              {
+                "name": "groupByItem",
+                "type": "HTMLElement",
+                "description": "The currently selected `ui5-group-item`."
+              },
+              {
+                "name": "groupDescending",
+                "type": "Boolean",
+                "description": "The selected group order (true = descending, false = ascending)."
+              },
+              {
+                "name": "groupOrder",
+                "type": "String",
+                "description": "The current group order selected."
+              },
+              {
+                "name": "sortBy",
+                "type": "String",
+                "description": "The currently selected `ui5-sort-item` text attribute."
+              },
+              {
+                "name": "sortByItem",
+                "type": "HTMLElement",
+                "description": "The currently selected `ui5-sort-item`."
+              },
+              {
+                "name": "sortDescending",
+                "type": "Boolean",
+                "description": "The selected sort order (true = descending, false = ascending)."
+              },
+              {
+                "name": "sortOrder",
+                "type": "String",
+                "description": "The current sort order selected."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ViewSettingsDialogDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired after the dialog is opened.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "groupDescending": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the initial group order.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates if the dialog is open.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "sortDescending": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the initial sort order.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ViewSettingsDialogDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [
+        {
+          "name": "setConfirmedSettings",
+          "description": "Sets a JavaScript object, as settings to the `ViewSettingsDialog`. This method can be used after the dialog is initially open, as the dialog needs to set its initial settings. The `ViewSettingsDialog` throws an event called \"before-open\", which can be used as a trigger point. The object should have the following format:",
+          "params": [
+            {
+              "name": "settings",
+              "type": {
+                "name": "VSDSettings"
+              },
+              "description": ""
+            }
+          ],
+          "returns": {
+            "type": "void"
+          }
+        }
+      ],
+      "cssParts": [
+        {
+          "name": "header",
+          "description": "Used to style the header."
+        }
+      ]
+    },
+    "Wizard": {
+      "package": "@ui5/webcomponents-react",
+      "description": "The `Wizard` helps users to complete a complex task by dividing it into sections and guiding them through it.\nIt has two main areas - a navigation area at the top showing the step sequence and a content area below it.\n\n### Structure\n#### Navigation area\nThe top most area of the `Wizard` is occupied by the navigation area.\nIt shows the sequence of steps, where the recommended number of steps is between 3 and 8 steps.\n\n-  Steps can have different visual representations - numbers or icons.\n-  Steps might have labels for better readability - titleText and subTitleText.\n-  Steps are defined by using the `WizardStep` as slotted element within the `Wizard`.\n\n**Note:** If no selected step is defined, the first step will be auto selected.\n\n**Note:** If multiple selected steps are defined, the last step will be selected.\n\n### Keyboard Handling\nThe user can navigate using the following keyboard shortcuts:\n\n#### Wizard Progress Navigation\n\n\t- [Left] or [Down] - Focus moves backward to the WizardProgressNavAnchors.\n\t- [Up] or [Right] - Focus moves forward to the WizardProgressNavAnchor.\n\t- [Space] / [Enter] or [Return] - Selects an active step\n\t- [Home] or [PAGE UP] - Focus goes to the first step\n\t- [End] or [PAGE DOWN] - Focus goes to the last step\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n#### Content\nThe content occupies the main part of the page. It can hold any type of HTML elements.\nIt's defined by using the `WizardStep` as slotted element within the `Wizard`.\n\n### Scrolling\nThe component handles user scrolling by selecting the closest step, based on the current scroll position\nand scrolls to particular place, when the user clicks on the step within the navigation area.\n\n**Important:** In order the component's scrolling behaviour to work, it has to be limited from the outside parent element in terms of height.\nThe component or its parent has to be given percentage or absolute height. Otherwise, the component will be scrolled out with the entire page.\n\n**For example:**\n\n```html\n<ui5-dialog style=\"height: 80%\">\n\t<Wizard></Wizard>\n</ui5-dialog>\n```\n\n#### Moving to next step\nThe `WizardStep` provides the necessary API and it's up to the user of the component to use it to move to the next step.\nYou have to set its `selected` property (and remove the `disabled` one if set) to `true`.\nThe `Wizard` will automatically scroll to the content of the newly selected step.\n\nThe Fiori 3 guidelines recommends having a \"nextStep\" button in the content area.\nYou can place a button, or any other type of element to trigger step change, inside the `WizardStep`,\nand show/hide it when certain fields are filled or user defined criteria is met.\n\n### Usage\n#### When to use:\nWhen the user has to accomplish a long or unfamiliar task.\n\n#### When not to use:\nWhen the task has less than 3 steps.\n\n### Responsive Behavior\nOn small widths the step's titleText, subtitleText and separators in the navigation area shrink and from particular point the steps are grouped together and overlap.\nTapping on them will show a popover to select the step to navigate to. On mobile device, the grouped steps are presented within a dialog.\n\n (includes <ui5-wizard-step/>)\n\n__Note:__ This is a UI5 Web Component! [Wizard UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/Wizard) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the steps.\n\n**Note:** Use the available `WizardStep` component.\n\n__Supported Node Type/s:__ `Array<WizardStep>`"
+        },
+        "onStepChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<WizardDomRef, WizardStepChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the step is changed by user interaction - either with scrolling,\nor by clicking on the steps within the component header.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "previousStep",
+                "type": "WizardStep",
+                "description": "The previous step."
+              },
+              {
+                "name": "step",
+                "type": "WizardStep",
+                "description": "The new step."
+              },
+              {
+                "name": "withScroll",
+                "type": "boolean",
+                "description": "true when the event occurs due to user scrolling."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "contentLayout": {
+          "type": {
+            "name": "enum",
+            "raw": "WizardContentLayout | \"MultipleSteps\" | \"SingleStep\"",
+            "value": [
+              {
+                "value": "\"MultipleSteps\"",
+                "description": "Display the content of the `ui5-wizard` as multiple steps in a scroll section."
+              },
+              {
+                "value": "\"SingleStep\"",
+                "description": "Display the content of the `ui5-wizard` as single step."
+              },
+              {
+                "value": "\"MultipleSteps\""
+              },
+              {
+                "value": "\"SingleStep\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines how the content of the `Wizard` would be visualized.\n\n**Note:** Available since [v1.14.0](https://github.com/UI5/webcomponents/releases/tag/v1.14.0) of **@ui5/webcomponents-fiori**.",
+          "defaultValue": {
+            "value": "\"MultipleSteps\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<WizardDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "navigator",
+          "description": "Used to style the progress navigator of the `ui5-wizard`."
+        },
+        {
+          "name": "step-content",
+          "description": "Used to style a `ui5-wizard-step` container."
+        }
+      ]
+    },
+    "WizardStep": {
+      "package": "@ui5/webcomponents-react",
+      "description": "A component that represents a logical step as part of the `Wizard`.\nIt is meant to aggregate arbitrary HTML elements that form the content of a single step.\n\n### Structure\n\n- Each wizard step has arbitrary content.\n- Each wizard step might have texts - defined by the `titleText` and `subtitleText` properties.\n- Each wizard step might have an icon - defined by the `icon` property.\n- Each wizard step might display a number in place of the `icon`, when it's missing.\n\n### Usage\nThe `WizardStep` component should be used only as slot of the `Wizard` component\nand should not be used standalone.\n\n__Note:__ This is a UI5 Web Component! [WizardStep UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/WizardStep) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the step content.\n\n__Supported Node Type/s:__ `Array<Node>`"
+        },
+        "branching": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "When `branching` is enabled a dashed line would be displayed after the step,\nmeant to indicate that the next step is not yet known and depends on user choice in the current step.\n\n**Note:** It is recommended to use `branching` on the last known step\nand later add new steps when it becomes clear how the wizard flow should continue.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the step is `disabled`. When disabled the step is displayed,\nbut the user can't select the step by clicking or navigate to it with scrolling.\n\n**Note:** Step can't be `selected` and `disabled` at the same time.\nIn this case the `selected` property would take precedence.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `icon` of the step.\n\n**Note:** The icon is displayed in the `Wizard` navigation header.\n\nThe SAP-icons font provides numerous options.\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "selected": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the step's `selected` state - the step that is currently active.\n\n**Note:** Step can't be `selected` and `disabled` at the same time.\nIn this case the `selected` property would take precedence.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "subtitleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `subtitleText` of the step.\n\n**Note:** the text is displayed in the `Wizard` navigation header."
+        },
+        "titleText": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the `titleText` of the step.\n\n**Note:** The text is displayed in the `Wizard` navigation header."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<WizardStepDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    }
+  },
+  "charts": {
+    "BarChart": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "A `BarChart` is a data visualization where each category is represented by a rectangle, with the width of the rectangle being proportional to the values being plotted.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "dimensions": {
+          "type": {
+            "name": "DimensionConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x axis"
+        },
+        "measures": {
+          "type": {
+            "name": "MeasureConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object is defining one bar in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this bar should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_OrderedColor_` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this bar.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: bar width, defaults to `auto`\n- `opacity`: bar opacity, defaults to `1`\n- `stackId`: bars with the same stackId will be stacked\n- `highlightColor`: function will be called to define a custom color of a specific element which matches the\n   defined condition. Overwrites code>color</code> of the element."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "dataset": {
+          "type": {
+            "name": "Record<string, unknown>[]"
+          },
+          "required": false,
+          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
+        },
+        "noLegend": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when clicked anywhere in the chart."
+        },
+        "onDataPointClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
+        },
+        "onLegendClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noAnimation` disables all chart animations when set to `true`."
+        },
+        "chartConfig": {
+          "type": {
+            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
+          },
+          "required": false,
+          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
+        },
+        "tooltipConfig": {
+          "type": {
+            "name": "TooltipProps<string | number | (string | number)[], string | number>"
+          },
+          "required": false,
+          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
+        },
+        "syncId": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
+        },
+        "ChartPlaceholder": {
+          "type": {
+            "name": "ComponentType"
+          },
+          "required": false,
+          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "BulletChart": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "The `BulletChart` is used to compare primary and secondary (comparison) values. The primary and additional values\nare rendered as a stacked Bar Chart while the comparison value is displayed as a line above.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "dimensions": {
+          "type": {
+            "name": "DimensionConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x axis"
+        },
+        "measures": {
+          "type": {
+            "name": "MeasureConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object is defining one element in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this element should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n- `type`: string which chart element (value type) to show. Possible values: `primary`, `comparison`, `additional`.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this element.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: width of the current chart element, defaults to `1` for `lines` and `20` for bars\n- `opacity`: element opacity, defaults to `1`\n- `highlightColor`: function will be called to define a custom color of a specific element which matches the\n   defined condition. Overwrites code>color</code> of the element."
+        },
+        "layout": {
+          "type": {
+            "name": "enum",
+            "raw": "\"horizontal\" | \"vertical\"",
+            "value": [
+              {
+                "value": "\"horizontal\""
+              },
+              {
+                "value": "\"vertical\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "layout for showing measures. `horizontal` bars would equal the column chart, `vertical` would be a bar chart.\nDefault Value: `horizontal`",
+          "defaultValue": {
+            "value": "`\"horizontal\"`"
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "dataset": {
+          "type": {
+            "name": "Record<string, unknown>[]"
+          },
+          "required": false,
+          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
+        },
+        "noLegend": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when clicked anywhere in the chart."
+        },
+        "onDataPointClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
+        },
+        "onLegendClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noAnimation` disables all chart animations when set to `true`."
+        },
+        "chartConfig": {
+          "type": {
+            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
+          },
+          "required": false,
+          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
+        },
+        "tooltipConfig": {
+          "type": {
+            "name": "TooltipProps<string | number | (string | number)[], string | number>"
+          },
+          "required": false,
+          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
+        },
+        "syncId": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
+        },
+        "ChartPlaceholder": {
+          "type": {
+            "name": "ComponentType"
+          },
+          "required": false,
+          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ColumnChart": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "A `ColumnChart` is a data visualization where each category is represented by a rectangle, with the height of the rectangle being proportional to the values being plotted.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "dimensions": {
+          "type": {
+            "name": "DimensionConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x axis"
+        },
+        "measures": {
+          "type": {
+            "name": "MeasureConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object is defining one column in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this column should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this column.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: column width, defaults to `auto`\n- `opacity`: column opacity, defaults to `1`\n- `stackId`: columns with the same stackId will be stacked\n- `highlightColor`: function will be called to define a custom color of a specific element which matches the\n   defined condition. Overwrites code>color</code> of the element."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "dataset": {
+          "type": {
+            "name": "Record<string, unknown>[]"
+          },
+          "required": false,
+          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
+        },
+        "noLegend": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when clicked anywhere in the chart."
+        },
+        "onDataPointClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
+        },
+        "onLegendClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noAnimation` disables all chart animations when set to `true`."
+        },
+        "chartConfig": {
+          "type": {
+            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
+          },
+          "required": false,
+          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
+        },
+        "tooltipConfig": {
+          "type": {
+            "name": "TooltipProps<string | number | (string | number)[], string | number>"
+          },
+          "required": false,
+          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
+        },
+        "syncId": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
+        },
+        "ChartPlaceholder": {
+          "type": {
+            "name": "ComponentType"
+          },
+          "required": false,
+          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ColumnChartWithTrend": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "A `ColumnChartWithTrend` is a data visualization where each category is represented by a rectangle, with the height of the rectangle being proportional to the values being plotted amd a trend line which is displayed above the column chart.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "dimensions": {
+          "type": {
+            "name": "DimensionConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x-axis"
+        },
+        "measures": {
+          "type": {
+            "name": "MeasureConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object is defining one column in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this column should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this column.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: column width, defaults to `auto`\n- `opacity`: column opacity, defaults to `1`\n- `stackId`: columns with the same stackId will be stacked\n- `highlightColor`: function will be called to define a custom color of a specific element which matches the\n   defined condition. Overwrites code>color</code> of the element."
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when clicked anywhere in the chart."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "dataset": {
+          "type": {
+            "name": "Record<string, unknown>[]"
+          },
+          "required": false,
+          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
+        },
+        "noLegend": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
+        },
+        "onDataPointClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
+        },
+        "onLegendClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noAnimation` disables all chart animations when set to `true`."
+        },
+        "chartConfig": {
+          "type": {
+            "name": "Omit<ICartesianChartConfig, \"secondYAxis\" | \"secondYAxisConfig\"> & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | ... 1 more ... | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessib..."
+          },
+          "required": false,
+          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
+        },
+        "tooltipConfig": {
+          "type": {
+            "name": "TooltipProps<string | number | (string | number)[], string | number>"
+          },
+          "required": false,
+          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
+        },
+        "ChartPlaceholder": {
+          "type": {
+            "name": "ComponentType"
+          },
+          "required": false,
+          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ComposedChart": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "The `ComposedChart` enables you to combine different chart types in one chart, e.g. showing bars together with lines.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "dimensions": {
+          "type": {
+            "name": "DimensionConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x axis"
+        },
+        "measures": {
+          "type": {
+            "name": "MeasureConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object is defining one element in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this element should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n- `type`: string which chart element to show. Possible values: `line`, `bar`, `area`.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this element.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: width of the current chart element, defaults to `1` for `lines` and `20` for bars\n- `opacity`: element opacity, defaults to `1`\n- `stackId`: bars with the same stackId will be stacked\n- `highlightColor`: function will be called to define a custom color of a specific element which matches the\n   defined condition. Overwrites code>color</code> of the element."
+        },
+        "layout": {
+          "type": {
+            "name": "enum",
+            "raw": "\"horizontal\" | \"vertical\"",
+            "value": [
+              {
+                "value": "\"horizontal\""
+              },
+              {
+                "value": "\"vertical\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "layout for showing measures. `horizontal` bars would equal the column chart, `vertical` would be a bar chart.\nDefault Value: `horizontal`",
+          "defaultValue": {
+            "value": "`\"horizontal\"`"
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "dataset": {
+          "type": {
+            "name": "Record<string, unknown>[]"
+          },
+          "required": false,
+          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
+        },
+        "noLegend": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when clicked anywhere in the chart."
+        },
+        "onDataPointClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
+        },
+        "onLegendClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noAnimation` disables all chart animations when set to `true`."
+        },
+        "chartConfig": {
+          "type": {
+            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
+          },
+          "required": false,
+          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
+        },
+        "tooltipConfig": {
+          "type": {
+            "name": "TooltipProps<string | number | (string | number)[], string | number>"
+          },
+          "required": false,
+          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
+        },
+        "syncId": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
+        },
+        "ChartPlaceholder": {
+          "type": {
+            "name": "ComponentType"
+          },
+          "required": false,
+          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "DonutChart": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "A `DonutChart` is a type of graph that displays data in a circular graph with a cut-out hole in the middle.\nThe pieces of the graph are proportional to the fraction of the whole in each category.\nA `DonutChart` is basically a `PieChart` with a hole.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "centerLabel": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A label to display in the center of the `PieChart`.\nIf you use this prop to display a text, we recommend to increase `chartConfig.innerRadius` to have some free\nspace for the text."
+        },
+        "dimension": {
+          "type": {
+            "name": "IChartDimension"
+          },
+          "required": true,
+          "description": "A object which contains the configuration of the dimension.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs"
+        },
+        "measure": {
+          "type": {
+            "name": "MeasureConfig"
+          },
+          "required": true,
+          "description": "A object which contains the configuration of the measure. The object is defining one pie in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this pie should display. Supports object structures by using <code>'parent.child'</code>.\n\n**Optional properties**\n\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `DataLabel`: a custom component to be used for the data label\n- `colors`: array of any valid CSS Color or CSS Variable. Defaults to the `sapChart_OrderedColor_` colors\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this segment. When passed a function it will be called for each data label with the corresponding chart properties."
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when clicked anywhere in the chart."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "dataset": {
+          "type": {
+            "name": "Record<string, unknown>[]"
+          },
+          "required": false,
+          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
+        },
+        "noLegend": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
+        },
+        "onDataPointClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
+        },
+        "onLegendClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noAnimation` disables all chart animations when set to `true`."
+        },
+        "chartConfig": {
+          "type": {
+            "name": "IPolarChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | \"left\" | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
+          },
+          "required": false,
+          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
+        },
+        "tooltipConfig": {
+          "type": {
+            "name": "TooltipProps<string | number | (string | number)[], string | number>"
+          },
+          "required": false,
+          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
+        },
+        "syncId": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
+        },
+        "ChartPlaceholder": {
+          "type": {
+            "name": "ComponentType"
+          },
+          "required": false,
+          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "LineChart": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "A `LineChart` is a type of chart used to show information that changes over time - it connects multiple dots.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "dimensions": {
+          "type": {
+            "name": "DimensionConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x axis"
+        },
+        "measures": {
+          "type": {
+            "name": "MeasureConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object is defining one line in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this line should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this line.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: line width, defaults to `1`\n- `opacity`: line opacity, defaults to `1`\n- `showDot`: Flag whether the line dot should be displayed or not.\n- `lineConfig`: This prop allows passing all [Line Properties](https://recharts.org/en-US/api/Line) of the Recharts library."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "dataset": {
+          "type": {
+            "name": "Record<string, unknown>[]"
+          },
+          "required": false,
+          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
+        },
+        "noLegend": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when clicked anywhere in the chart."
+        },
+        "onDataPointClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
+        },
+        "onLegendClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noAnimation` disables all chart animations when set to `true`."
+        },
+        "chartConfig": {
+          "type": {
+            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
+          },
+          "required": false,
+          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
+        },
+        "tooltipConfig": {
+          "type": {
+            "name": "TooltipProps<string | number | (string | number)[], string | number>"
+          },
+          "required": false,
+          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
+        },
+        "syncId": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
+        },
+        "ChartPlaceholder": {
+          "type": {
+            "name": "ComponentType"
+          },
+          "required": false,
+          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "PieChart": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "A Pie Chart is a type of graph that displays data in a circular graph.\nThe pieces of the graph are proportional to the fraction of the whole in each category.\n\nIn other words, each slice of the pie is relative to the size of that category in the group as a whole.\nThe entire “pie” represents 100 percent of a whole, while the pie “slices” represent portions of the whole.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "centerLabel": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A label to display in the center of the `PieChart`.\nIf you use this prop to display a text, we recommend to increase `chartConfig.innerRadius` to have some free\nspace for the text."
+        },
+        "dimension": {
+          "type": {
+            "name": "IChartDimension"
+          },
+          "required": true,
+          "description": "A object which contains the configuration of the dimension.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs"
+        },
+        "measure": {
+          "type": {
+            "name": "MeasureConfig"
+          },
+          "required": true,
+          "description": "A object which contains the configuration of the measure. The object is defining one pie in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this pie should display. Supports object structures by using <code>'parent.child'</code>.\n\n**Optional properties**\n\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `DataLabel`: a custom component to be used for the data label\n- `colors`: array of any valid CSS Color or CSS Variable. Defaults to the `sapChart_OrderedColor_` colors\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this segment. When passed a function it will be called for each data label with the corresponding chart properties."
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when clicked anywhere in the chart."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "dataset": {
+          "type": {
+            "name": "Record<string, unknown>[]"
+          },
+          "required": false,
+          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
+        },
+        "noLegend": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
+        },
+        "onDataPointClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
+        },
+        "onLegendClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noAnimation` disables all chart animations when set to `true`."
+        },
+        "chartConfig": {
+          "type": {
+            "name": "IPolarChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | \"left\" | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
+          },
+          "required": false,
+          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
+        },
+        "tooltipConfig": {
+          "type": {
+            "name": "TooltipProps<string | number | (string | number)[], string | number>"
+          },
+          "required": false,
+          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
+        },
+        "syncId": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
+        },
+        "ChartPlaceholder": {
+          "type": {
+            "name": "ComponentType"
+          },
+          "required": false,
+          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "RadarChart": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "A radar or spider or web chart is a two-dimensional chart type designed to plot one or more series of values over multiple quantitative variables.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "dimensions": {
+          "type": {
+            "name": "IChartDimension[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties*\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs"
+        },
+        "measures": {
+          "type": {
+            "name": "MeasureConfig[]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object is defining one radar in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this radar should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this radar.\n- `DataLabel`: a custom component to be used for the data label\n- `opacity`: radar opacity, defaults to `0.5`"
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "dataset": {
+          "type": {
+            "name": "Record<string, unknown>[]"
+          },
+          "required": false,
+          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
+        },
+        "noLegend": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when clicked anywhere in the chart."
+        },
+        "onDataPointClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
+        },
+        "onLegendClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noAnimation` disables all chart animations when set to `true`."
+        },
+        "chartConfig": {
+          "type": {
+            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
+          },
+          "required": false,
+          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
+        },
+        "tooltipConfig": {
+          "type": {
+            "name": "TooltipProps<string | number | (string | number)[], string | number>"
+          },
+          "required": false,
+          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
+        },
+        "syncId": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
+        },
+        "ChartPlaceholder": {
+          "type": {
+            "name": "ComponentType"
+          },
+          "required": false,
+          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "RadialChart": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "Displays a ring chart highlighting a current status.\nThe status can be emphasized by using the `color` prop.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "value": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The actual value which defines how much the ring is filled."
+        },
+        "maxValue": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The maximum value of the ring. If `value` >= `maxValue`, the ring will be filled to 100%.\n\n__Default:__ `100`."
+        },
+        "displayValue": {
+          "type": {
+            "name": "string | number"
+          },
+          "required": false,
+          "description": "The value that should be displayed in the center of the `RadialChart`."
+        },
+        "displayValueStyle": {
+          "type": {
+            "name": "CSSProperties"
+          },
+          "required": false,
+          "description": "Font size of the `displayValue`.\n\n__Default values:__\n\n- fontSize: `1.25rem`\n- fill: `ThemingParameters.sapTextColor`"
+        },
+        "color": {
+          "type": {
+            "name": "Color"
+          },
+          "required": false,
+          "description": "A custom color you want to apply to the ring fill. This props accepts any valid CSS color or CSS variable."
+        },
+        "onDataPointClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ value: number; payload: unknown; dataIndex: number; }>) => void"
+          },
+          "required": false,
+          "description": "`onDataPointClick` fires when the user clicks on the filled part of the ring."
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; dataIndex: number; value: number; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when clicked anywhere in the chart."
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noAnimation` disables all chart animations when set to `true`."
+        },
+        "chartConfig": {
+          "type": {
+            "name": "RadialChartConfig"
+          },
+          "required": false,
+          "description": "Defines possible configurations of the internally used [RadialBarChart](https://recharts.org/en-US/api/RadialBarChart).\n\n__Note:__ It is possible to overwrite internally used props. Please use with caution!\n\n__Default values:__\n\n- margin: `{ top: 5, right: 5, bottom: 5, left: 5 }`\n- innerRadius: `\"90%\"`\n- outerRadius: `\"100%\"`"
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ScatterChart": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "\nA `ScatterChart` is a data visualization that displays multiple circles (bubbles) in a two-dimensional plot.\n\nMost commonly, a scatter chart displays the values of three numeric variables,where each observation's data is\nshown by a circle, while the horizontal and vertical positions of the bubble show the values of two other variables.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "dataset": {
+          "type": {
+            "name": "ScatterDataObject[]"
+          },
+          "required": false,
+          "description": "An array of dataset objects. Each object defines a dataset which is displayed.\n\n**Required properties**\n - `data`: array of objects which contains the data.\n\n**Optional properties**\n - `label`: string containing the label of the dataset which is also displayed in the legend.\n - `color`: any valid CSS color or CSS variable. Defaults to the `sapChart_Ordinal` colors.\n - `opacity`: number contains value of opacity of dataset\n\n**Example of dataset:**\n\n<code>\n  <pre>\n   [\n     {\n      label: 'America',\n      opacity: 0.7,\n      data: [\n        {\n          users: 120,\n          sessions: 200,\n          volume: 302\n        },\n        {\n          users: 20,\n          sessions: 230,\n          volume: 392\n        }\n      ]\n     }\n   ]\n  </pre>\n</code>"
+        },
+        "measures": {
+          "type": {
+            "name": "[MeasureConfig, MeasureConfig, MeasureConfig, ...MeasureConfig[]]"
+          },
+          "required": true,
+          "description": "An array of config objects. Each object is defining one axis in the chart.\n\n**Required properties**\n - `accessor`: string containing the path to the dataset key this line should display. Supports object structures by using <code>'parent.child'</code>.\n    Can also be a getter.\n - `axis`: string containing definition of axis. Must be x, y or z data to the axis.\n\n**Optional properties**\n - `label`: Label to display in tooltips. Falls back to the <code>accessor</code> if not present.\n - `formatter`: function will be called for each data label and allows you to format it according to your needs. Also addresses labels of axis."
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
+          },
+          "required": false,
+          "description": "Fired when clicked anywhere in the chart."
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
+        },
+        "loadingDelay": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
+          "defaultValue": {
+            "value": "1000"
+          }
+        },
+        "noLegend": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
+        },
+        "onDataPointClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
+        },
+        "onLegendClick": {
+          "type": {
+            "name": "(event: CustomEvent<any>) => void"
+          },
+          "required": false,
+          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
+        },
+        "noAnimation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "`noAnimation` disables all chart animations when set to `true`."
+        },
+        "chartConfig": {
+          "type": {
+            "name": "IScatterChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
+          },
+          "required": false,
+          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
+        },
+        "tooltipConfig": {
+          "type": {
+            "name": "TooltipProps<string | number | (string | number)[], string | number>"
+          },
+          "required": false,
+          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
+        },
+        "syncId": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
+        },
+        "ChartPlaceholder": {
+          "type": {
+            "name": "ComponentType"
+          },
+          "required": false,
+          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TimelineChart": {
+      "package": "@ui5/webcomponents-react-charts",
+      "description": "> __Experimental Component!__ <br />\n\nA `TimelineChart` is a data visualization chart that can be used to represent\nGantt charts or any other timeline-based visualizations. The component has a\nrich set of various properties that allows the user to:\n* Zoom the chart body to see the visualizations clearer using the mouse wheel.\n* Pan the zoomed chart horizonatally by holding down the left click button.\n* Add annotations to highlight or illustrate different points on the timeline.\n* Use annotations to create custom Timeline visualizations.\n* Choose whether the timeline is discrete or continous.\n* Show relationships between different items on the timeline using different\nconnections.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "dataset": {
+          "type": {
+            "name": "ITimelineChartRow[]"
+          },
+          "required": false,
+          "description": "The data is an array of objects that is displayed on the chart."
+        },
+        "totalDuration": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The total duration of the timeline.",
+          "defaultValue": {
+            "value": "10"
+          }
+        },
+        "width": {
+          "type": {
+            "name": "Width<string | number>"
+          },
+          "required": false,
+          "description": "The total width of the chart. If not supplied, the chart's\nwidth expands to fill its conatainer.",
+          "defaultValue": {
+            "value": "auto"
+          }
+        },
+        "rowHeight": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The height the row of the timeline.",
+          "defaultValue": {
+            "value": "25"
+          }
+        },
+        "isDiscrete": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Whether the timeline is a continuous timeline or broken\ninto discrete sections."
+        },
+        "annotations": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the annonations to be applied on top on the chart.\n\n**Note:** Use the `TimelineChartAnnotation` component here."
+        },
+        "showAnnotation": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Toggles the visibility of the annotations applied to the chart."
+        },
+        "showConnection": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Toggles the visibility of the connections of the task and milestone\nitems in the chart."
+        },
+        "hideTooltip": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Toggles the visibility of the tooltip."
+        },
+        "unit": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "The unit of the duration of the timeline."
+        },
+        "rowTitle": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "The label for the activity axis.",
+          "defaultValue": {
+            "value": "Activities"
+          }
+        },
+        "columnTitle": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "The label for the title of the duration axis.",
+          "defaultValue": {
+            "value": "Duration"
+          }
+        },
+        "discreteLabels": {
+          "type": {
+            "name": "string[]"
+          },
+          "required": false,
+          "description": "The label for the columns if the chart is separated into discrete columns\nbased on if `isDiscrete` is true. If set, the length of this array\n__must__ be equal to the `totalDuration`. If not set, an\narray of numbers with size equal to the `totalDuration` and with values\nstarting from the value __start__ prop of the `TimelineChart` will be used."
+        },
+        "start": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "The starting value of the timeline duration.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "valueFormat": {
+          "type": {
+            "name": "(value: number) => string"
+          },
+          "required": false,
+          "description": "A callback function that is applied to each value in the tick and tootltip\nto format how it is displayed.",
+          "defaultValue": {
+            "value": "(x: number) => x.toFixed(1)"
+          }
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<HTMLDivElement>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    }
+  },
+  "ai": {
+    "Button": {
+      "package": "@ui5/webcomponents-ai-react",
+      "description": "The `Button` component serves as a button for AI-related scenarios. Users can trigger actions by clicking or tapping the `Button`\nor by pressing keyboard keys like [Enter] or [Space].\n\n### Usage\n\nFor the `Button` user interface, you can define one or more button states by placing `ButtonState` components in their default slot.\nEach state has a name for identification and can include text, an icon, and an end icon, as needed for its purpose.\nYou can define a split mode for the `Button`, which will results in displaying an arrow button for additional actions.\n\nYou can choose from a set of predefined designs for `Button` (as in `ui5-button`) to match the desired styling.\n\nThe `Button` can be activated by clicking or tapping it. You can change the button state in the click event handler. When the button is\nin split mode, you can activate the default button action by clicking or tapping it, or by pressing keyboard keys like [Enter] or [Space].\nYou can activate the arrow button by clicking or tapping it, or by pressing keyboard keys like [Arrow Up], [Arrow Down], or [F4].\nTo display additional actions, you can attach a menu to the arrow button.\n\n\n\n__Note:__ This is a UI5 Web Component! [Button UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ai/Button) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the available states of the component.\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that\nyou only use `ButtonState` components in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<ButtonState>`"
+        },
+        "onArrowButtonClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ButtonDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is in split mode and after the arrow button\nis activated either by clicking or tapping it or by using the [Arrow Up] / [Arrow Down],\n[Alt] + [Arrow Up]/ [Arrow Down], or [F4] keyboard keys.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<ButtonDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the component is activated either with a\nmouse/tap or by using the Enter or Space key.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "accessibilityAttributes": {
+          "type": {
+            "name": "AIButtonAccessibilityAttributes"
+          },
+          "required": false,
+          "description": "Defines the additional accessibility attributes that will be applied to the component.\n\nThis property allows for fine-tuned control of ARIA attributes for screen reader support.\nIt accepts an object with the following optional fields:\n\n- **root**: Accessibility attributes that will be applied to the root element.\n - **hasPopup**: Indicates the availability and type of interactive popup element (such as a menu or dialog).\n   Accepts string values: `\"dialog\"`, `\"grid\"`, `\"listbox\"`, `\"menu\"`, or `\"tree\"`.\n - **roleDescription**: Defines a human-readable description for the button's role.\n   Accepts any string value.\n - **title**: Specifies a tooltip or description for screen readers.\n   Accepts any string value.\n- **ariaKeyShortcuts**: Defines keyboard shortcuts that activate or focus the button.\n\n- **arrowButton**: Accessibility attributes that will be applied to the arrow (split) button element.\n - **hasPopup**: Indicates the type of popup triggered by the arrow button.\n   Accepts string values: `\"dialog\"`, `\"grid\"`, `\"listbox\"`, `\"menu\"`, or `\"tree\"`.\n - **expanded**: Indicates whether the popup controlled by the arrow button is currently expanded.\n   Accepts boolean values: `true` or `false`.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "{}"
+          }
+        },
+        "arrowButtonPressed": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines the active state of the arrow button in split mode.\nSet to true when the button is in split mode and a menu with additional options\nis opened by the arrow button. Set back to false when the menu is closed.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "design": {
+          "type": {
+            "name": "enum",
+            "raw": "ButtonDesign | \"Default\" | \"Positive\" | \"Negative\" | \"Transparent\" | \"Emphasized\" | \"Attention\"",
+            "value": [
+              {
+                "value": "\"Default\"",
+                "description": "default type (no special styling)"
+              },
+              {
+                "value": "\"Positive\"",
+                "description": "accept type (green button)"
+              },
+              {
+                "value": "\"Negative\"",
+                "description": "reject style (red button)"
+              },
+              {
+                "value": "\"Transparent\"",
+                "description": "transparent type"
+              },
+              {
+                "value": "\"Emphasized\"",
+                "description": "emphasized type"
+              },
+              {
+                "value": "\"Attention\"",
+                "description": "attention type"
+              },
+              {
+                "value": "\"Default\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Transparent\""
+              },
+              {
+                "value": "\"Emphasized\""
+              },
+              {
+                "value": "\"Attention\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the component design.",
+          "defaultValue": {
+            "value": "\"Default\""
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "state": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the current state of the component."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ButtonDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "ButtonState": {
+      "package": "@ui5/webcomponents-ai-react",
+      "description": "`ButtonState` is the item to use for defining states of `Button` components.\n\n### Usage\n\n`ButtonState` is an abstract element, representing a state of `Button`. It is meant to be used in the `default` slot\nof `Button` and should not be used as standalone component.\n\n\n\n__Note:__ This is a UI5 Web Component! [ButtonState UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ai/ButtonState) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "endIcon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed as graphical element within the component after the text.\nThe SAP-icons font provides numerous options.\n\n**Example:**\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "icon": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed as graphical element within the component before the text.\nThe SAP-icons font provides numerous options.\n\n**Example:**\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the name of the button state."
+        },
+        "showArrowButton": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines if the component is in split button mode.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "text": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the text of the button in this state."
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<ButtonStateDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "Input": {
+      "package": "@ui5/webcomponents-ai-react",
+      "description": "The `Input` component extends the standard `ui5-input` with **AI Writing Assistant** capabilities.\n\n### Structure\n\nThe `Input` consists of the following main parts:\n\n- **Input Field** – Inherits all standard Input behaviors.\n- **AI Action Button** – Appears when focused or loading, providing access to AI-related actions or stopping generation.\n\nThe component automatically determines which elements to render based on its internal state:\n- The AI Button is only shown when there are available `actions`.\n- The version navigation appears only when `totalVersions > 1`.\n\n### Keyboard Support\n\n- **Shift + F4** — Opens the AI menu.\n- **Ctrl + Shift + Z / Y** — Navigates backward/forward between AI-generated versions.\n\n\n\n__Note:__ This is a UI5 Web Component! [Input UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ai/Input) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "actions": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the items of the menu for the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"actions\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the suggestion items.\n\n**Note:** The suggestions would be displayed only if the `showSuggestions`\nproperty is set to `true`.\n\n**Note:** The `<ui5-suggestion-item>`, `<ui5-suggestion-item-group>` and `ui5-suggestion-item-custom` are recommended to be used as suggestion items.\n\n__Supported Node Type/s:__ `Array<IInputSuggestionItem>`"
+        },
+        "icon": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the icon to be displayed in the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
+        },
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n**Note:** If the component has `suggestionItems`,\nthe `valueStateMessage` would be displayed as part of the same popover, if used on desktop, or dialog - on phone.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onButtonClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user selects the AI button.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": false
+          }
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onClose": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the suggestions picker is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the component changes at each keystroke,\nand when a suggestion item has been selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onItemClick": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, MenuItemClickEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when an item from the AI actions menu is clicked.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The currently clicked menu item."
+              },
+              {
+                "name": "text",
+                "type": "string",
+                "description": "The text of the currently clicked menu item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": false
+          }
+        },
+        "onOpen": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the suggestions picker is open.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSelect": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when some text has been selected.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSelectionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, InputSelectionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user navigates to a suggestion item via the ARROW keys,\nas a preview, before the final selection.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "item",
+                "type": "HTMLElement",
+                "description": "The previewed suggestion item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onStopGeneration": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user selects the \"Stop\" button to stop ongoing AI text generation.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onVersionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<InputDomRef, InputVersionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user selects the version navigation buttons.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "backwards",
+                "type": "boolean",
+                "description": "The text of the currently clicked menu item."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": false
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents-ai**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents-ai**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the input."
+        },
+        "currentVersion": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Indicates the index of the currently displayed version.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "filter": {
+          "type": {
+            "name": "enum",
+            "raw": "InputSuggestionsFilter | \"StartsWithPerTerm\" | \"StartsWith\" | \"Contains\" | \"None\"",
+            "value": [
+              {
+                "value": "\"StartsWithPerTerm\"",
+                "description": "Defines filtering by first symbol of each word of item's text."
+              },
+              {
+                "value": "\"StartsWith\"",
+                "description": "Defines filtering by starting symbol of item's text."
+              },
+              {
+                "value": "\"Contains\"",
+                "description": "Defines contains filtering."
+              },
+              {
+                "value": "\"None\"",
+                "description": "Removes any filtering applied while typing"
+              },
+              {
+                "value": "\"StartsWithPerTerm\""
+              },
+              {
+                "value": "\"StartsWith\""
+              },
+              {
+                "value": "\"Contains\""
+              },
+              {
+                "value": "\"None\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the filter type of the component.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the AI Writing Assistant is currently loading.\n\nWhen `true`, indicates that an AI action is in progress.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "maxlength": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Sets the maximum number of characters available in the input field.\n\n**Note:** This property is not compatible with the ui5-input type InputType.Number. If the ui5-input type is set to Number, the maxlength value is ignored."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
+        },
+        "noTypeahead": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the value will be autcompleted to match an item\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "open": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the suggestions picker is open.\nThe picker will not open if the `showSuggestions` property is set to `false`, the input is disabled or the input is readonly.\nThe picker will close automatically and `close` event will be fired if the input is not in the viewport.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showClearIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showSuggestions": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should show suggestions, if such are present.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "totalVersions": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Indicates the total number of result versions available.\n\nWhen not set or set to 0, the versioning will be hidden.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "type": {
+          "type": {
+            "name": "enum",
+            "raw": "InputType | \"Text\" | \"Email\" | \"Number\" | \"Password\" | \"Tel\" | \"URL\" | \"Search\"",
+            "value": [
+              {
+                "value": "\"Text\"",
+                "description": "Defines a one-line text input field:"
+              },
+              {
+                "value": "\"Email\"",
+                "description": "Used for input fields that must contain an e-mail address."
+              },
+              {
+                "value": "\"Number\"",
+                "description": "Defines a numeric input field."
+              },
+              {
+                "value": "\"Password\"",
+                "description": "Defines a password field."
+              },
+              {
+                "value": "\"Tel\"",
+                "description": "Used for input fields that should contain a telephone number."
+              },
+              {
+                "value": "\"URL\"",
+                "description": "Used for input fields that should contain a URL address."
+              },
+              {
+                "value": "\"Search\"",
+                "description": "Used for input fields that should contain a search term."
+              },
+              {
+                "value": "\"Text\""
+              },
+              {
+                "value": "\"Email\""
+              },
+              {
+                "value": "\"Number\""
+              },
+              {
+                "value": "\"Password\""
+              },
+              {
+                "value": "\"Tel\""
+              },
+              {
+                "value": "\"URL\""
+              },
+              {
+                "value": "\"Search\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the HTML type of the component.\n\n**Notes:**\n\n- The particular effect of this property differs depending on the browser\nand the current language settings, especially for type `Number`.\n- The property is mostly intended to be used with touch devices\nthat use different soft keyboard layouts depending on the given input type.",
+          "defaultValue": {
+            "value": "\"Text\""
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<InputDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "clear-icon",
+          "description": "Used to style the clear icon, which can be pressed to clear user input text"
+        },
+        {
+          "name": "input",
+          "description": "Used to style the native input element"
+        },
+        {
+          "name": "root",
+          "description": "Used to style the root DOM element of the Input component"
+        }
+      ]
+    },
+    "PromptInput": {
+      "package": "@ui5/webcomponents-ai-react",
+      "description": "The `PromptInput` component allows the user to write custom instructions in natural language, so that AI is guided to generate content tailored to user needs.\n\n**Note:** The web component is in an experimental state\n\n\n\n__Note:__ This is a UI5 Web Component! [PromptInput UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ai/PromptInput) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "children": {
+          "type": {
+            "name": "ReactNode | ReactNode[]"
+          },
+          "required": false,
+          "description": "Defines the suggestion items.\n\n**Note:** The suggestions would be displayed only if the `showSuggestions`\nproperty is set to `true`.\n\n**Note:** The `<ui5-suggestion-item>`, `<ui5-suggestion-item-group>` and `ui5-suggestion-item-custom` are recommended to be used as suggestion items.\n\n__Supported Node Type/s:__ `Array<IInputSuggestionItem>`"
+        },
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<PromptInputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter\nor on focusout.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<PromptInputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the component changes at each keystroke,\nand when a suggestion item has been selected.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSubmit": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<PromptInputDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the input operation has finished by pressing Enter\nor AI button is clicked.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "label": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the label of the input field.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**."
+        },
+        "maxlength": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Sets the maximum number of characters available in the input field.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**."
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showClearIcon": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showExceededText": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the characters exceeding the maximum allowed character count are visible\nin the component.\n\nIf set to `false`, the user is not allowed to enter more characters than what is set in the\n`maxlength` property.\nIf set to `true` the characters exceeding the `maxlength` value are selected on\npaste and the counter below the component displays their number.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "showSuggestions": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should show suggestions, if such are present.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<PromptInputDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": []
+    },
+    "TextArea": {
+      "package": "@ui5/webcomponents-ai-react",
+      "description": "The `TextArea` component extends the standard TextArea with Writing Assistant capabilities.\nIt provides AI-powered text generation, editing suggestions, and version management functionality.\n\n### Structure\nThe `TextArea` consists of the following elements:\n- TextArea: The main text input area with all standard textarea functionality\n- WritingAssistant: Dedicated toolbar containing:\n  - Versioning: A component with left/right navigation buttons and a label for browsing AI-generated versions\n  - AI Button: Opens a menu that can be extended with custom AI generation options through slotting\n\n\n\n__Note:__ This is a UI5 Web Component! [TextArea UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ai/TextArea) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
+      "props": {
+        "menu": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines a slot for `ui5-menu` integration. This slot allows you to pass a `ui5-menu` instance that will be associated with the assistant.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"menu\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `HTMLElement`"
+        },
+        "valueStateMessage": {
+          "type": {
+            "name": "UI5WCSlotsNode"
+          },
+          "required": false,
+          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed if the component has\n`valueState` of type `Information`, `Critical` or `Negative`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
+        },
+        "onChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the text has changed and the focus leaves the component.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onInput": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TextAreaDomRef, TextAreaInputEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the value of the component changes at each keystroke or when\nsomething is pasted.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "escapePressed",
+                "type": "boolean",
+                "description": "Indicates whether the Escape key was pressed, which triggers a revert to the previous value"
+              }
+            ],
+            "cancelable": true,
+            "bubbles": true
+          }
+        },
+        "onScroll": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when textarea is scrolled.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onSelect": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when some text has been selected.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
+          "eventDetail": {
+            "params": [],
+            "cancelable": false,
+            "bubbles": true
+          }
+        },
+        "onStopGeneration": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user requests to stop AI text generation.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
+        },
+        "onVersionChange": {
+          "type": {
+            "name": "(event: Ui5CustomEvent<TextAreaDomRef, TextAreaVersionChangeEventDetail>) => void"
+          },
+          "required": false,
+          "description": "Fired when the user clicks on version navigation buttons.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
+          "eventDetail": {
+            "params": [
+              {
+                "name": "backwards",
+                "type": "boolean",
+                "description": "Indicates if navigation is backwards (true) or forwards (false, default)."
+              }
+            ],
+            "cancelable": false,
+            "bubbles": false
+          }
+        },
+        "accessibleDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-ai**."
+        },
+        "accessibleDescriptionRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that describe the textarea.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-ai**."
+        },
+        "accessibleName": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the accessible ARIA name of the component."
+        },
+        "accessibleNameRef": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Receives id(or many ids) of the elements that label the textarea."
+        },
+        "currentVersion": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Indicates the index of the currently displayed version.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "disabled": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Indicates whether the user can interact with the component or not.\n\n**Note:** A disabled component is completely noninteractive.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "growing": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Enables the component to automatically grow and shrink dynamically with its content.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "growingMaxRows": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the maximum number of rows that the component can grow.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "loading": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the `TextArea` is currently in a loading(processing) state.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "maxlength": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the maximum number of characters that the `value` can have."
+        },
+        "name": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
+        },
+        "placeholder": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines a short hint intended to aid the user with data entry when the component has no value."
+        },
+        "promptDescription": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the prompt description of the current action."
+        },
+        "readonly": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "required": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component is required.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "rows": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Defines the number of visible text rows for the component.\n\n**Notes:**\n\n- If the `growing` property is enabled, this property defines the minimum rows to be displayed\nin the textarea.\n- The CSS `height` property wins over the `rows` property, if both are set.",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "showExceededText": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Determines whether the characters exceeding the maximum allowed character count are visible\nin the component.\n\nIf set to `false`, the user is not allowed to enter more characters than what is set in the\n`maxlength` property.\nIf set to `true` the characters exceeding the `maxlength` value are selected on\npaste and the counter below the component displays their number.",
+          "defaultValue": {
+            "value": "false"
+          }
+        },
+        "totalVersions": {
+          "type": {
+            "name": "number"
+          },
+          "required": false,
+          "description": "Indicates the total number of result versions available.\n\nNotes:\nVersioning is hidden if the value is `0`",
+          "defaultValue": {
+            "value": "0"
+          }
+        },
+        "value": {
+          "type": {
+            "name": "string"
+          },
+          "required": false,
+          "description": "Defines the value of the component."
+        },
+        "valueState": {
+          "type": {
+            "name": "enum",
+            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
+            "value": [
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              },
+              {
+                "value": "\"None\""
+              },
+              {
+                "value": "\"Positive\""
+              },
+              {
+                "value": "\"Critical\""
+              },
+              {
+                "value": "\"Negative\""
+              },
+              {
+                "value": "\"Information\""
+              }
+            ]
+          },
+          "required": false,
+          "description": "Defines the value state of the component.\n\n**Note:** If `maxlength` property is set,\nthe component turns into \"Critical\" state once the characters exceeds the limit.\nIn this case, only the \"Negative\" state is considered and can be applied.",
+          "defaultValue": {
+            "value": "\"None\""
+          }
+        },
+        "waitForDefine": {
+          "type": {
+            "name": "boolean"
+          },
+          "required": false,
+          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
+        },
+        "ref": {
+          "type": {
+            "name": "Ref<TextAreaDomRef>"
+          },
+          "required": false,
+          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
+        },
+        "key": {
+          "type": {
+            "name": "Key"
+          },
+          "required": false,
+          "description": ""
+        }
+      },
+      "methods": [],
+      "cssParts": [
+        {
+          "name": "textarea",
+          "description": "Used to style the native textarea"
+        }
+      ]
+    }
+  },
+  "metadata": {
+    "version": "2.20.1",
+    "extractedAt": "2026-03-20T09:28:13.408Z",
+    "componentsCount": 26,
+    "webComponentsCount": 161,
+    "chartsCount": 12,
+    "aiCount": 5
+  }
+}
diff --git a/packages/mcp-server/src/tools/get_component_api/get_component_api.ts b/packages/mcp-server/src/tools/get_component_api/get_component_api.ts
new file mode 100644
index 00000000000..b9c6df35e9c
--- /dev/null
+++ b/packages/mcp-server/src/tools/get_component_api/get_component_api.ts
@@ -0,0 +1,193 @@
+/**
+ * @fileOverview get_component_api tool
+ * Get comprehensive API documentation for a UI5 Web Components React component
+ */
+
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+import type { ApiDataStore, ComponentApiData } from '../../types/index.js';
+import { handleToolError } from '../../utils/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+type GetComponentApiPayload = {
+  componentName: string;
+};
+
+// Load API data at module initialization
+let API_DATA: ApiDataStore = { components: {}, webComponents: {}, charts: {}, ai: {} };
+
+try {
+  const apiDataPath = join(__dirname, 'component-apis.json');
+  API_DATA = JSON.parse(readFileSync(apiDataPath, 'utf-8'));
+} catch (error) {
+  console.warn('Could not load component API data:', error);
+}
+
+/**
+ * Find a component by name (case-insensitive search across all categories)
+ */
+function findComponent(name: string): { name: string; data: ComponentApiData; category: string } | null {
+  const lowerName = name.toLowerCase();
+
+  for (const category of ['components', 'webComponents', 'charts', 'ai'] as const) {
+    const found = Object.entries(API_DATA[category]).find(([key]) => key.toLowerCase() === lowerName);
+    if (found) {
+      return {
+        name: found[0],
+        data: found[1],
+        category,
+      };
+    }
+  }
+
+  return null;
+}
+
+// ============================================================================
+// TOOL DEFINITION
+// ============================================================================
+
+export const getComponentApiTool = {
+  name: 'get_component_api',
+  title: 'Component API Reference',
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description: `Get comprehensive API documentation for a UI5 Web Components React component including props, ref methods, types, event detail parameters, and CSS parts for shadow DOM styling.
+
+WHEN TO USE: You need exact prop names, types, default values, method signatures, event detail fields, or CSS part selectors for a specific component.
+DO NOT USE FOR: General guidance on styling, events, or architecture — use get_documentation instead. To discover component names — use list_components first.
+WORKFLOW: Use list_components to find the correct component name, then this tool for full API details.
+LIMITS: Returns data for one component per call. Returns all props and methods for that component.
+
+EXAMPLE INPUT: { "componentName": "Dialog" }
+
+**Output Format (JSON):**
+\`\`\`typescript
+{
+  package: string,                    // NPM package name
+  description: string,                 // Full JSDoc description with @tags, examples, notes
+  props: {
+    [propName: string]: {
+      type: {
+        name: string,                  // Type category (e.g., "string", "boolean", "enum")
+        raw?: string,                  // Full TypeScript type string
+        value?: Array<{                // For enums: possible values with descriptions
+          value: string,
+          description?: string
+        }>
+      },
+      required: boolean,               // Whether prop is required
+      defaultValue: any,               // Default value if specified
+      description: string,             // Full prop description with notes
+      eventDetail?: {                  // Present on event handler props (web components only)
+        params: Array<{                // Fields available on e.detail
+          name: string,                // e.g., "targetRef", "escPressed", "item"
+          type: string,                // e.g., "HTMLElement", "boolean"
+          description: string          // What this detail field contains
+        }>,
+        cancelable: boolean,           // true = e.preventDefault() prevents the action
+        bubbles: boolean               // true = event bubbles through DOM
+      }
+    }
+  },
+  methods: Array<{                     // Imperative handle methods (access via ref.current.methodName())
+    name: string,
+    description: string,
+    params: Array<{
+      name: string,
+      description: string,
+      type: any
+    }>,
+    returns: any
+  }>,
+  cssParts?: Array<{                   // CSS ::part() selectors for shadow DOM styling (web components only)
+    name: string,                      // Use as: componentSelector::part(name) { ... }
+    description: string
+  }>
+}
+\`\`\`
+
+**Note:** Generic HTML attributes (className, style, onClick, etc.) are filtered out but available via CommonProps. Ref methods are accessed via \`componentRef.current.methodName()\`. Event detail fields (eventDetail.params) tell you what's on \`e.detail\` — access via \`e.detail.paramName\`.`,
+  inputSchema: {
+    componentName: z
+      .string()
+      .describe(
+        'Component name (e.g., "Button", "AnalyticalTable"). Case-insensitive. Must match a component from @ui5/webcomponents-react, @ui5/webcomponents-react-charts, or @ui5/webcomponents-ai-react.',
+      ),
+  },
+  outputSchema: {
+    package: z.string().describe('NPM package name'),
+    description: z.string().describe('Full component description'),
+    props: z.record(z.any()).describe('Component props with types, descriptions, and eventDetail'),
+    methods: z.array(z.any()).describe('Imperative methods accessible via ref'),
+    cssParts: z
+      .array(z.object({ name: z.string(), description: z.string() }))
+      .optional()
+      .describe('CSS ::part() selectors for shadow DOM styling'),
+    _meta: z.object({
+      apiVersion: z.string(),
+      extractedAt: z.string().optional(),
+    }),
+    error: z.string().optional().describe('Error message if component not found'),
+    errorType: z
+      .enum(['not_found', 'invalid_input'])
+      .optional()
+      .describe('Semantic error type for programmatic handling'),
+    availableComponents: z
+      .array(z.string())
+      .optional()
+      .describe('List of all valid component names (only present on not_found errors)'),
+  },
+  handler: ({ componentName }: GetComponentApiPayload) => {
+    try {
+      const normalizedName = componentName.trim();
+      const found = findComponent(normalizedName);
+
+      if (!found) {
+        const allComponents = [
+          ...Object.keys(API_DATA.components),
+          ...Object.keys(API_DATA.webComponents),
+          ...Object.keys(API_DATA.charts),
+          ...Object.keys(API_DATA.ai),
+        ].sort();
+
+        return {
+          structuredContent: {
+            error: `Component '${componentName}' not found.`,
+            errorType: 'not_found' as const,
+            availableComponents: allComponents,
+          },
+          content: [
+            {
+              type: 'text' as const,
+              text: `Component '${componentName}' not found. Use list_components to discover available component names.`,
+            },
+          ],
+        };
+      }
+
+      const response = {
+        ...found.data,
+        _meta: {
+          apiVersion: API_DATA.metadata?.version ?? 'unknown',
+          extractedAt: API_DATA.metadata?.extractedAt,
+        },
+      };
+
+      return {
+        structuredContent: response,
+        content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+      };
+    } catch (error) {
+      return handleToolError(error, `Error getting API for component '${componentName}'`);
+    }
+  },
+};
diff --git a/packages/mcp-server/src/tools/get_documentation/documentation_sections.json b/packages/mcp-server/src/tools/get_documentation/documentation_sections.json
new file mode 100644
index 00000000000..f3eeac8d0e9
--- /dev/null
+++ b/packages/mcp-server/src/tools/get_documentation/documentation_sections.json
@@ -0,0 +1,272 @@
+{
+  "sections": [
+    {
+      "name": "Getting Started",
+      "description": "Entry point for developers new to UI5 Web Components for React. Covers installation, configuration, and core concepts needed to set up a project.",
+      "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/getting-started--docs",
+      "sourcePath": "docs/Welcome.mdx",
+      "content": [
+        "Library installation",
+        "Peer dependencies setup (@ui5/webcomponents, @ui5/webcomponents-fiori)",
+        "ThemeProvider configuration",
+        "React 18+ requirement",
+        "Node.js LTS",
+        "TypeScript 4.7+ support",
+        "Wrapper components concept",
+        "Custom element prop handling"
+      ],
+      "tags": ["onboarding", "setup", "installation", "initialization", "dependencies", "requirements"],
+      "localPath": "docs--Welcome.mdx"
+    },
+    {
+      "name": "Project Templates & Examples",
+      "description": "Ready-to-use project templates and code examples for rapid development. Includes Vite, Next.js, and React Router examples with pre-configured setups.",
+      "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/project-templates-examples--docs",
+      "dataSource": "docs/project-templates.json",
+      "content": [
+        "Vite-TS template",
+        "Create React App template",
+        "Next.js (App Router & Pages Router) examples",
+        "CodeSandbox examples",
+        "Pre-configured dependencies",
+        "Import structures",
+        "ThemeProvider wrapping",
+        "Styling setup"
+      ],
+      "tags": ["boilerplate", "starter-projects", "examples", "vite", "next.js", "templates", "quickstart"],
+      "localPath": "docs--project-templates.md"
+    },
+    {
+      "name": "Knowledge Base",
+      "description": "Collection of detailed guides covering advanced topics, best practices, and solutions for common development scenarios.",
+      "subsections": [
+        {
+          "name": "Bring Your Own Web Components",
+          "description": "Guide for wrapping and integrating custom web components into the React framework using CLI tools and code-mods.",
+          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-bring-your-own-web-components--docs",
+          "sourcePath": "docs/knowledge-base/BringYourOwnWebComponents.mdx",
+          "content": [
+            "Wrapping custom web components",
+            "Custom element integration",
+            "Wrapper component generation",
+            "CLI tools",
+            "Code-mods",
+            "Third-party component support",
+            "React event handling",
+            "Boolean attributes",
+            "Slot composition"
+          ],
+          "tags": [
+            "custom-components",
+            "web-components",
+            "wrapper-generation",
+            "extensibility",
+            "cli-tools",
+            "integration"
+          ],
+          "localPath": "docs--knowledge-base--BringYourOwnWebComponents.mdx"
+        },
+        {
+          "name": "Common CSS",
+          "description": "Reference for styling approaches including CSS Modules, design tokens, theming parameters, and design system integration.",
+          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-common-css--docs",
+          "sourcePath": "docs/knowledge-base/CommonCSS.mdx",
+          "content": [
+            "CSS Modules usage",
+            "CSS-in-JS libraries",
+            "JSS to CSS Modules transition",
+            "Semantic design tokens",
+            "CSS variables",
+            "Theming parameters",
+            "Customization scopes (global/component/element)",
+            "Design system consistency"
+          ],
+          "tags": ["styling", "css-modules", "css-variables", "theming", "design-tokens", "customization"],
+          "localPath": "docs--knowledge-base--CommonCSS.mdx"
+        },
+        {
+          "name": "FAQ",
+          "description": "Frequently asked questions addressing common developer concerns, troubleshooting issues, and best practices.",
+          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-faq--docs",
+          "sourcePath": "docs/knowledge-base/FAQ.mdx",
+          "content": ["Common developer concerns", "Troubleshooting solutions", "Recurring problems", "Best practices"],
+          "tags": ["troubleshooting", "best-practices", "common-issues", "faq"],
+          "localPath": "docs--knowledge-base--FAQ.mdx"
+        },
+        {
+          "name": "Handling Slots",
+          "description": "Documentation on Web Components slots mechanism for component composition and content projection.",
+          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs",
+          "sourcePath": "docs/knowledge-base/CustomComponentsSlots.mdx",
+          "content": [
+            "Web Components slot mechanism",
+            "Named slots",
+            "Default slots",
+            "Children injection",
+            "ReactNode support",
+            "Slot documentation per component",
+            "Content projection"
+          ],
+          "tags": ["slots", "composition", "web-components", "children-injection", "component-design"],
+          "localPath": "docs--knowledge-base--CustomComponentsSlots.mdx"
+        },
+        {
+          "name": "IDs via dataset",
+          "description": "Guide for using HTML data-* attributes and dataset API for DOM element identification in testing and component logic.",
+          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-ids-via-dataset--docs",
+          "sourcePath": "docs/knowledge-base/ChangeEvents.mdx",
+          "content": [
+            "HTML data-* attributes",
+            "Dataset API",
+            "DOM element identification",
+            "Test element selection",
+            "Data attribute usage",
+            "Cypress integration"
+          ],
+          "tags": ["testing", "dom-queries", "data-attributes", "selectors", "identification", "test-utilities"],
+          "localPath": "docs--knowledge-base--ChangeEvents.mdx"
+        },
+        {
+          "name": "Internationalization",
+          "description": "Comprehensive guide for multi-language support including locale configuration, RTL support, and formatting for different regions.",
+          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-internationalization--docs",
+          "sourcePath": "docs/knowledge-base/Internationalization.mdx",
+          "content": [
+            "Multi-language support",
+            "Locale detection",
+            "supportedLocales configuration",
+            "fallbackLocale handling",
+            "RTL language support",
+            "Locale resolution",
+            "Number/date/currency formatting"
+          ],
+          "tags": ["i18n", "localization", "multi-language", "rtl", "locale-configuration", "l10n"],
+          "localPath": "docs--knowledge-base--Internationalization.mdx"
+        },
+        {
+          "name": "Public Utils",
+          "description": "Reference documentation for utility functions and helpers from the @ui5/webcomponents-react-base package.",
+          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-public-utils--docs",
+          "sourcePath": "docs/knowledge-base/Public-Utils.mdx",
+          "content": [
+            "Utility functions from @ui5/webcomponents-react-base",
+            "ThemingParameters object",
+            "Design token access",
+            "Helper methods",
+            "API functions"
+          ],
+          "tags": ["utilities", "helpers", "base-package", "theming-api", "api-functions"],
+          "localPath": "docs--knowledge-base--Public-Utils.mdx"
+        },
+        {
+          "name": "Server Side Rendering",
+          "description": "Implementation guide for using Web Components with SSR frameworks like Next.js, addressing hydration and component loading strategies.",
+          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-server-side-rendering--docs",
+          "sourcePath": "docs/knowledge-base/ServerSideRendering.mdx",
+          "content": [
+            "SSR with Next.js (Pages & App Router)",
+            "Shadow DOM challenges",
+            "useEffect hooks for client-side rendering",
+            "Transpile module settings",
+            "Static site generation (SSG)",
+            "Hydration strategies"
+          ],
+          "tags": ["ssr", "next.js", "ssg", "hydration", "static-generation", "performance", "server-side-rendering"],
+          "localPath": "docs--knowledge-base--ServerSideRendering.mdx"
+        },
+        {
+          "name": "Styling",
+          "description": "Comprehensive guide covering CSS Modules, theming parameters, design tokens, and multiple styling approaches for components.",
+          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-styling--docs",
+          "sourcePath": "docs/knowledge-base/Styling.mdx",
+          "content": [
+            "Changing CSS variables on web component selectors",
+            "CSS Shadow Parts (::part pseudo-element)",
+            "CSS Custom States (:state pseudo-class)",
+            "Styling custom components with SAP CSS variables",
+            "ThemingParameters for JavaScript access",
+            "Applying className and style props",
+            "Explicitly importing CSS bundles",
+            "Scrollbar customization",
+            "Common CSS (@sap-ui/common-css)"
+          ],
+          "tags": [
+            "styling",
+            "css",
+            "theming",
+            "design-system",
+            "customization",
+            "css-variables",
+            "shadow-parts",
+            "custom-states",
+            "css-layer"
+          ],
+          "localPath": "docs--knowledge-base--Styling.mdx"
+        },
+        {
+          "name": "Accessibility",
+          "description": "How to make UI5 Web Components applications accessible. Covers accessibility APIs (accessibleName, accessibleNameRef, accessibleDescription, accessibleRole, accessibilityAttributes), label-input relationships, invisible messaging, keyboard handling, and high contrast themes.",
+          "link": "https://ui5.github.io/webcomponents/docs/advanced/accessibility/",
+          "localPath": "upstream--accessibility.mdx",
+          "content": [
+            "Accessibility proxy attributes (accessibleName, accessibleNameRef, accessibleRole)",
+            "Label-input relationships (<Label for=...>)",
+            "Icon accessibility modes (Image, Interactive, Decorative)",
+            "Invisible messaging for screen reader announcements",
+            "High contrast theme detection and application",
+            "Heading semantic levels",
+            "Tooltip usage"
+          ],
+          "tags": [
+            "accessibility",
+            "a11y",
+            "aria",
+            "screen-reader",
+            "keyboard-navigation",
+            "high-contrast",
+            "accessible-name",
+            "accessible-role"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "Patterns",
+      "description": "Architecture patterns, best practices, and experimental features for common use cases and advanced component interactions.",
+      "subsections": [
+        {
+          "name": "Docs",
+          "description": "Architectural examples and design patterns demonstrating common use cases, component interactions, and composition strategies.",
+          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/patterns-docs--docs",
+          "sourcePath": "docs/Patterns.mdx",
+          "content": [
+            "Architectural examples",
+            "Common use cases",
+            "Component interactions",
+            "Master-detail views",
+            "Form handling",
+            "Data management strategies",
+            "Composition patterns"
+          ],
+          "tags": ["patterns", "architecture", "best-practices", "examples", "use-cases", "component-patterns"],
+          "localPath": "docs--Patterns.mdx"
+        },
+        {
+          "name": "SelectionAssistant (Exp)",
+          "description": "Experimental pattern for advanced multi-selection scenarios with filtering and search capabilities.",
+          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/patterns-selectionassistant-experimental--docs",
+          "sourcePath": "patterns/selection-assistant/SelectionAssistant.mdx",
+          "content": [
+            "Experimental multi-selection pattern",
+            "Advanced filtering",
+            "Search capabilities",
+            "Selection handling",
+            "Component state management"
+          ],
+          "tags": ["patterns", "experimental", "selection", "multi-select", "advanced-features", "component-patterns"],
+          "localPath": "patterns--selection-assistant--SelectionAssistant.mdx"
+        }
+      ]
+    }
+  ]
+}
diff --git a/packages/mcp-server/src/tools/get_documentation/get_documentation.ts b/packages/mcp-server/src/tools/get_documentation/get_documentation.ts
new file mode 100644
index 00000000000..a56252a5206
--- /dev/null
+++ b/packages/mcp-server/src/tools/get_documentation/get_documentation.ts
@@ -0,0 +1,496 @@
+/**
+ * @fileOverview get_documentation tool
+ * Provides access to UI5 Web Components for React documentation, FAQ, guides, and patterns
+ */
+
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+import type { DocumentationData } from '../../types/index.js';
+import { createTextResponse, handleToolError } from '../../utils/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+type GetDocumentationPayload = {
+  section?: string;
+  query?: string;
+  fetchContent?: boolean;
+  startLine?: number;
+  endLine?: number;
+};
+
+// Load documentation metadata at module initialization
+let DOCS_DATA: DocumentationData = { sections: [] };
+
+try {
+  const docsDataPath = join(__dirname, 'documentation_sections.json');
+  DOCS_DATA = JSON.parse(readFileSync(docsDataPath, 'utf-8'));
+} catch (error) {
+  console.warn('Could not load documentation metadata:', error);
+}
+
+/**
+ * Get all available section names with descriptions
+ */
+function getAllSectionNames(): Array<{ name: string; description: string }> {
+  const sections: Array<{ name: string; description: string }> = [];
+
+  for (const section of DOCS_DATA.sections) {
+    if (section.link) {
+      sections.push({
+        name: section.name,
+        description: section.description,
+      });
+    }
+
+    if (section.subsections) {
+      for (const subsection of section.subsections) {
+        sections.push({
+          name: `${section.name} > ${subsection.name}`,
+          description: subsection.description,
+        });
+      }
+    }
+  }
+
+  return sections;
+}
+
+/**
+ * Get documentation by section name (human-readable)
+ */
+function getDocumentationBySection(sectionName: string): Array<{
+  section: string;
+  subsection?: string;
+  description: string;
+  link: string;
+  localPath?: string;
+  content: string[];
+  tags: string[];
+}> {
+  for (const section of DOCS_DATA.sections) {
+    // Check if it's a direct section match
+    if (section.link && section.name === sectionName) {
+      return [
+        {
+          section: section.name,
+          description: section.description,
+          link: section.link,
+          localPath: section.localPath,
+          content: section.content || [],
+          tags: section.tags || [],
+        },
+      ];
+    }
+
+    // Check subsections (format: "Section > Subsection")
+    if (section.subsections) {
+      for (const subsection of section.subsections) {
+        const fullName = `${section.name} > ${subsection.name}`;
+        if (fullName === sectionName) {
+          return [
+            {
+              section: section.name,
+              subsection: subsection.name,
+              description: subsection.description,
+              link: subsection.link,
+              localPath: subsection.localPath,
+              content: subsection.content,
+              tags: subsection.tags,
+            },
+          ];
+        }
+      }
+    }
+  }
+
+  return [];
+}
+
+/**
+ * Search for documentation sections matching a query
+ */
+function searchDocumentation(query: string): Array<{
+  section: string;
+  subsection?: string;
+  description: string;
+  link: string;
+  localPath?: string;
+  content: string[];
+  tags: string[];
+  matchReason: string;
+}> {
+  const results: Array<{
+    section: string;
+    subsection?: string;
+    description: string;
+    link: string;
+    localPath?: string;
+    content: string[];
+    tags: string[];
+    matchReason: string;
+  }> = [];
+
+  const lowerQuery = query.toLowerCase();
+
+  for (const section of DOCS_DATA.sections) {
+    // Check if section matches
+    const sectionNameMatch = section.name.toLowerCase().includes(lowerQuery);
+    const sectionDescMatch = section.description.toLowerCase().includes(lowerQuery);
+    const sectionTagMatch = section.tags?.some((tag) => tag.toLowerCase().includes(lowerQuery));
+
+    if (sectionNameMatch || sectionDescMatch || sectionTagMatch) {
+      if (section.link) {
+        // Section has direct content
+        results.push({
+          section: section.name,
+          description: section.description,
+          link: section.link,
+          localPath: section.localPath,
+          content: section.content || [],
+          tags: section.tags || [],
+          matchReason: sectionNameMatch ? 'name' : sectionDescMatch ? 'description' : 'tag',
+        });
+      }
+    }
+
+    // Check subsections
+    if (section.subsections) {
+      for (const subsection of section.subsections) {
+        const subNameMatch = subsection.name.toLowerCase().includes(lowerQuery);
+        const subDescMatch = subsection.description.toLowerCase().includes(lowerQuery);
+        const subTagMatch = subsection.tags.some((tag) => tag.toLowerCase().includes(lowerQuery));
+        const subContentMatch = subsection.content.some((item) => item.toLowerCase().includes(lowerQuery));
+
+        if (subNameMatch || subDescMatch || subTagMatch || subContentMatch) {
+          results.push({
+            section: section.name,
+            subsection: subsection.name,
+            description: subsection.description,
+            link: subsection.link,
+            localPath: subsection.localPath,
+            content: subsection.content,
+            tags: subsection.tags,
+            matchReason: subNameMatch ? 'name' : subDescMatch ? 'description' : subTagMatch ? 'tag' : 'content',
+          });
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+// Path to bundled documentation files
+const DOCS_DIR = join(__dirname, '..', '..', '..', 'docs');
+
+/**
+ * Read documentation content from bundled local file.
+ * Optionally extracts a specific line range.
+ */
+function readDocContent(localPath?: string, startLine?: number, endLine?: number): string {
+  let fullContent: string | null = null;
+
+  if (localPath) {
+    try {
+      fullContent = readFileSync(join(DOCS_DIR, localPath), 'utf-8');
+    } catch {
+      // File not found
+    }
+  }
+
+  if (!fullContent) {
+    return 'Documentation content not available locally. The bundled docs may need to be regenerated with `npm run bundle:docs`.';
+  }
+
+  // Apply line range if specified
+  if (startLine || endLine) {
+    const lines = fullContent.split('\n');
+    const start = Math.max(1, startLine || 1) - 1; // Convert to 0-indexed
+    const end = Math.min(lines.length, endLine || lines.length);
+    const sliced = lines.slice(start, end);
+    return `[Lines ${start + 1}-${end} of ${lines.length}]\n\n${sliced.join('\n')}`;
+  }
+
+  return fullContent;
+}
+
+/**
+ * Format search results as markdown
+ */
+function formatResults(
+  results: Array<{
+    section: string;
+    subsection?: string;
+    description: string;
+    link: string;
+    localPath?: string;
+    content: string[];
+    tags: string[];
+  }>,
+  fetchedContent?: Map<string, string>,
+): string {
+  if (results.length === 0) {
+    return '# No Documentation Found\n\nNo documentation sections matched your query.';
+  }
+
+  let output = `# Documentation Results\n\nFound ${results.length} matching documentation ${results.length === 1 ? 'section' : 'sections'}:\n\n`;
+
+  for (const result of results) {
+    const title = result.subsection ? `${result.section} > ${result.subsection}` : result.section;
+
+    output += `## ${title}\n\n`;
+    output += `${result.description}\n\n`;
+    output += `**Link:** ${result.link}\n\n`;
+
+    if (result.content.length > 0) {
+      output += `**Topics Covered:**\n`;
+      for (const item of result.content) {
+        output += `- ${item}\n`;
+      }
+      output += '\n';
+    }
+
+    if (result.tags.length > 0) {
+      output += `**Tags:** ${result.tags.join(', ')}\n\n`;
+    }
+
+    // Include fetched content if available
+    if (fetchedContent && fetchedContent.has(result.link)) {
+      const content = fetchedContent.get(result.link);
+      if (content) {
+        output += `**Documentation Content:**\n\n${content}\n\n`;
+      }
+    }
+
+    output += '---\n\n';
+  }
+
+  return output;
+}
+
+/**
+ * List all available documentation sections
+ */
+function listAllDocumentation(): string {
+  let output = `# UI5 Web Components for React Documentation\n\n`;
+  output += `Complete documentation catalog with ${DOCS_DATA.sections.length} main sections and 19 total pages.\n\n`;
+
+  for (const section of DOCS_DATA.sections) {
+    output += `## ${section.name}\n\n`;
+    output += `${section.description}\n\n`;
+
+    if (section.link) {
+      output += `**Link:** ${section.link}\n\n`;
+    }
+
+    if (section.tags && section.tags.length > 0) {
+      output += `**Tags:** ${section.tags.join(', ')}\n\n`;
+    }
+
+    if (section.subsections) {
+      output += `**Subsections:**\n\n`;
+      for (const subsection of section.subsections) {
+        output += `### ${subsection.name}\n\n`;
+        output += `${subsection.description}\n\n`;
+        output += `**Link:** ${subsection.link}\n\n`;
+        if (subsection.tags.length > 0) {
+          output += `**Tags:** ${subsection.tags.join(', ')}\n\n`;
+        }
+      }
+    }
+
+    output += '---\n\n';
+  }
+
+  output += `\n## How to Use\n\n`;
+  output += `### Direct Access (by section name)\n\n`;
+  output += `Use the \`section\` parameter with the exact section name:\n\n`;
+  output += `**Examples:**\n`;
+  output += `- \`get_documentation({ section: "Getting Started" })\`\n`;
+  output += `- \`get_documentation({ section: "Knowledge Base > Styling" })\`\n\n`;
+
+  output += `### Flexible Search (by query)\n\n`;
+  output += `Use the \`query\` parameter to search across all documentation:\n\n`;
+  output += `**Examples:**\n`;
+  output += `- \`get_documentation({ query: "styling" })\` - Find all styling-related docs\n`;
+  output += `- \`get_documentation({ query: "i18n" })\` - Find internationalization docs\n\n`;
+
+  output += `### Fetch Full Content\n\n`;
+  output += `Add \`fetchContent: true\` to retrieve the full documentation markdown content:\n\n`;
+  output += `- \`get_documentation({ section: "Knowledge Base > FAQ", fetchContent: true })\`\n`;
+  output += `- \`get_documentation({ query: "styling", fetchContent: true })\`\n\n`;
+
+  output += `### Line Range (for large documents)\n\n`;
+  output += `Use \`startLine\` and \`endLine\` to read specific portions:\n\n`;
+  output += `- \`get_documentation({ section: "Getting Started", fetchContent: true, startLine: 1, endLine: 50 })\`\n`;
+
+  return output;
+}
+
+// ============================================================================
+// TOOL DEFINITION
+// ============================================================================
+
+export const getDocumentationTool = {
+  name: 'get_documentation',
+  title: 'Documentation & Guides',
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description:
+    'Retrieve UI5 Web Components for React documentation, guides, and knowledge base articles. ' +
+    'Documentation is bundled locally for instant offline access.\n\n' +
+    'WHEN TO USE: You need guidance on how to use the library — setup, styling, event handling, SSR, slots, i18n.\n' +
+    'DO NOT USE FOR: Looking up specific component props or methods — use get_component_api instead. For public utilities/hooks from @ui5/webcomponents-react-base — use get_public_utils.\n' +
+    'WORKFLOW: Call without parameters to see all available sections. Use section parameter for direct access, query for search.\n' +
+    'LIMITS: When fetchContent is true, full content is returned for at most 3 matching sections to control output size.\n\n' +
+    'EXAMPLE INPUT: { "section": "Knowledge Base > Styling", "fetchContent": true }\n' +
+    'EXAMPLE INPUT: { "query": "i18n", "fetchContent": true }\n' +
+    'EXAMPLE INPUT: {} (returns catalog of all documentation sections)',
+  inputSchema: {
+    section: z
+      .enum([
+        'Getting Started',
+        'Project Templates & Examples',
+        'Knowledge Base > Bring Your Own Web Components',
+        'Knowledge Base > Common CSS',
+        'Knowledge Base > FAQ',
+        'Knowledge Base > Handling Slots',
+        'Knowledge Base > IDs via dataset',
+        'Knowledge Base > Internationalization',
+        'Knowledge Base > Public Utils',
+        'Knowledge Base > Server Side Rendering',
+        'Knowledge Base > Styling',
+        'Knowledge Base > Accessibility',
+        'Patterns > Docs',
+        'Patterns > SelectionAssistant (Exp)',
+      ])
+      .optional()
+      .describe(
+        'Specific documentation section to retrieve by exact name. ' +
+          'Use this for direct access when you know which section you need. ' +
+          'Examples: "Getting Started", "Migration Guide", "Knowledge Base > Styling", ' +
+          '"Knowledge Base > Internationalization". ' +
+          'Mutually exclusive with query parameter.',
+      ),
+    query: z
+      .string()
+      .optional()
+      .describe(
+        'Free-form search query to find relevant documentation. ' +
+          'Searches across section names, descriptions, tags, and content topics. ' +
+          'Examples: "styling", "migration", "i18n", "ssr", "slots", "forms". ' +
+          "Use this for exploratory search when you're not sure which section you need. " +
+          'Mutually exclusive with section parameter.',
+      ),
+    fetchContent: z
+      .boolean()
+      .optional()
+      .default(false)
+      .describe(
+        'Whether to include the full documentation markdown content. ' +
+          'Set to true to retrieve full documentation text in addition to metadata. ' +
+          'Content is read from bundled local files (no network required). ' +
+          'Useful when you need detailed information beyond the summary.',
+      ),
+    startLine: z
+      .number()
+      .int()
+      .positive()
+      .optional()
+      .describe(
+        'Start line number (1-based, inclusive) for reading a portion of the documentation. ' +
+          'Requires fetchContent: true. Useful for large documents like the Change Log or Migration Guide.',
+      ),
+    endLine: z
+      .number()
+      .int()
+      .positive()
+      .optional()
+      .describe(
+        'End line number (1-based, inclusive) for reading a portion of the documentation. ' +
+          'Requires fetchContent: true. If omitted with startLine, reads to end of file.',
+      ),
+  },
+  handler: ({ section, query, fetchContent = false, startLine, endLine }: GetDocumentationPayload) => {
+    try {
+      // Validate line range parameters
+      if ((startLine || endLine) && !fetchContent) {
+        return createTextResponse('Error: startLine/endLine require fetchContent: true.');
+      }
+      if (startLine && endLine && startLine > endLine) {
+        return createTextResponse('Error: startLine must be less than or equal to endLine.');
+      }
+
+      // Validate that only one search method is used
+      if (section && query) {
+        return createTextResponse(
+          'Error: Please provide either "section" OR "query", not both.\n\n' +
+            '- Use "section" for direct access to a specific documentation page\n' +
+            '- Use "query" for flexible search across all documentation\n' +
+            '- Omit both to see all available sections',
+        );
+      }
+
+      // If no parameters, return all documentation overview
+      if (!section && !query) {
+        return createTextResponse(listAllDocumentation());
+      }
+
+      // Get results based on section or query
+      let results: Array<{
+        section: string;
+        subsection?: string;
+        description: string;
+        link: string;
+        localPath?: string;
+        content: string[];
+        tags: string[];
+      }> = [];
+
+      if (section) {
+        // Direct section access
+        results = getDocumentationBySection(section);
+        if (results.length === 0) {
+          const availableSections = getAllSectionNames();
+          return createTextResponse(
+            `Section "${section}" not found.\n\n` +
+              `Available sections:\n${availableSections.map((s) => `- ${s.name}`).join('\n')}`,
+          );
+        }
+      } else if (query) {
+        // Flexible search
+        results = searchDocumentation(query);
+      }
+
+      // Optionally read documentation content from bundled local files
+      let fetchedContent: Map<string, string> | undefined;
+      if (fetchContent && results.length > 0) {
+        fetchedContent = new Map();
+
+        // Limit to first 3 results to avoid excessive output
+        const resultsToFetch = results.slice(0, 3);
+
+        for (const result of resultsToFetch) {
+          const content = readDocContent(result.localPath, startLine, endLine);
+          if (content) {
+            fetchedContent.set(result.link, content);
+          }
+        }
+      }
+
+      return createTextResponse(formatResults(results, fetchedContent));
+    } catch (error) {
+      return handleToolError(
+        error,
+        `Error retrieving documentation${section ? ` for section: ${section}` : query ? ` for query: ${query}` : ''}`,
+      );
+    }
+  },
+};
diff --git a/packages/mcp-server/src/tools/get_public_utils/get_public_utils.ts b/packages/mcp-server/src/tools/get_public_utils/get_public_utils.ts
new file mode 100644
index 00000000000..3b92193d219
--- /dev/null
+++ b/packages/mcp-server/src/tools/get_public_utils/get_public_utils.ts
@@ -0,0 +1,421 @@
+/**
+ * get_public_utils tool
+ * Provides documentation for public utilities and hooks from @ui5/webcomponents-react-base
+ */
+
+import { z } from 'zod';
+import { createTextResponse, handleToolError } from '../../utils/index.js';
+
+type GetPublicUtilsPayload = {
+  name?: string;
+};
+
+const DEVICE_DOCS = `# Device API
+
+Import: \`import * as Device from '@ui5/webcomponents-react-base/Device';\`
+
+The Device API allows you to detect information about the environment where your app is running.
+
+## General Device Information
+
+- \`Device.isIE()\` - Returns true if running in Internet Explorer
+- \`Device.isSafari()\` - Returns true if running in Safari
+- \`Device.isDesktop()\` - Returns true if running on desktop devices
+- \`Device.isTablet()\` - Returns true if running on tablet devices
+- \`Device.isPhone()\` - Returns true if running on mobile phone devices
+- \`Device.supportsTouch()\` - Returns true if device supports touch
+- \`Device.getCurrentRange(width?: number)\` - Returns the current media range
+  - Returns: \`{ from: number, to?: number, name: 'Phone' | 'Tablet' | 'Desktop' | 'LargeDesktop', unit: string }\`
+- \`Device.getOrientation()\` - Returns the current orientation
+  - Returns: \`{ landscape: boolean, portrait: boolean }\`
+
+## Event Listeners
+
+- \`Device.attachResizeHandler(callback)\` - Attach handler for window resize
+  - Callback receives: \`{ height: number, width: number }\`
+- \`Device.detachResizeHandler(callback)\` - Detach resize handler
+- \`Device.attachOrientationChangeHandler(callback)\` - Attach handler for orientation change
+  - Callback receives: \`{ landscape: boolean, portrait: boolean }\`
+- \`Device.detachOrientationChangeHandler(callback)\` - Detach orientation handler
+- \`Device.attachMediaHandler(callback)\` - Attach handler for media query changes
+  - Matches against SAP Responsive Breakpoints:
+    - Phone: \`(max-width:599px)\`
+    - Tablet: \`(min-width:600px) and (max-width:1023px)\`
+    - Desktop: \`(min-width:1024px) and (max-width:1439px)\`
+    - LargeDesktop: \`(min-width:1440px)\`
+  - Callback receives: \`{ from: number, to?: number, name: string, unit: string }\`
+- \`Device.detachMediaHandler(callback)\` - Detach media handler
+
+## Example Usage
+
+\`\`\`tsx
+import * as Device from '@ui5/webcomponents-react-base/Device';
+
+function MyComponent() {
+  useEffect(() => {
+    const handleResize = ({ width, height }) => {
+      console.log('Window resized:', width, height);
+    };
+
+    Device.attachResizeHandler(handleResize);
+
+    return () => {
+      Device.detachResizeHandler(handleResize);
+    };
+  }, []);
+
+  const isPhone = Device.isPhone();
+  const range = Device.getCurrentRange();
+
+  return <div>Device type: {range.name}</div>;
+}
+\`\`\`
+`;
+
+const THEMING_PARAMETERS_DOCS = `# ThemingParameters
+
+Import: \`import { ThemingParameters } from '@ui5/webcomponents-react-base/ThemingParameters';\`
+
+ThemingParameters is a JavaScript object containing all available CSS variables mapped to their names. This allows you to use theme-aware colors and styles without hard-coding values.
+
+## Usage
+
+\`\`\`tsx
+import { ThemingParameters } from '@ui5/webcomponents-react-base/ThemingParameters';
+
+// Using in inline styles (not recommended for excessive use)
+<div style={{ background: ThemingParameters.sapBackgroundColor }} />
+
+// Equivalent to:
+<div style={{ background: 'var(--sapBackgroundColor)' }} />
+\`\`\`
+
+## Common Parameters
+
+- \`sapBackgroundColor\` - Default background color
+- \`sapTextColor\` - Default text color
+- \`sapBrandColor\` - Brand/primary color
+- \`sapHighlightColor\` - Highlight color
+- \`sapNegativeColor\` - Error/negative state color
+- \`sapCriticalColor\` - Warning/critical state color
+- \`sapPositiveColor\` - Success/positive state color
+- \`sapNeutralColor\` - Neutral/info state color
+- \`sapFontFamily\` - Default font family
+- \`sapFontSize\` - Base font size
+- \`sapFontLargeSize\` - Large font size
+- \`sapFontSmallSize\` - Small font size
+
+## Best Practices
+
+1. Prefer CSS variables in external stylesheets over inline styles
+2. Use ThemingParameters when dynamic styling in JavaScript is needed
+3. All parameters are theme-aware and change with the active theme
+4. Full list available at: https://github.com/SAP/theming-base-content
+
+## Example: Custom Component with Theming
+
+\`\`\`tsx
+import { ThemingParameters } from '@ui5/webcomponents-react-base/ThemingParameters';
+import './MyComponent.css';
+
+export const MyComponent = ({ isError }) => {
+  return (
+    <div
+      className="my-component"
+      style={{
+        color: isError ? ThemingParameters.sapNegativeColor : ThemingParameters.sapTextColor
+      }}
+    >
+      Content
+    </div>
+  );
+};
+\`\`\`
+
+\`\`\`css
+/* MyComponent.css */
+.my-component {
+  background-color: var(--sapBackgroundColor);
+  font-family: var(--sapFontFamily);
+  padding: var(--sapElement_Spacing);
+}
+\`\`\`
+`;
+
+const USE_I18N_BUNDLE_DOCS = `# useI18nBundle Hook
+
+Import: \`import { useI18nBundle } from '@ui5/webcomponents-react-base/hooks';\`
+
+The useI18nBundle hook enables internationalization (i18n) in your application by providing access to translated text bundles.
+
+## Signature
+
+\`\`\`typescript
+function useI18nBundle(bundleName: string): {
+  getText: (key: string, ...params: string[]) => string;
+}
+\`\`\`
+
+## Usage
+
+\`\`\`tsx
+import { useI18nBundle } from '@ui5/webcomponents-react-base/hooks';
+
+function MyComponent() {
+  const i18nBundle = useI18nBundle('@myapp/i18n');
+
+  return (
+    <div>
+      <h1>{i18nBundle.getText('WELCOME_MESSAGE')}</h1>
+      <p>{i18nBundle.getText('USER_GREETING', userName)}</p>
+    </div>
+  );
+}
+\`\`\`
+
+## Setup
+
+1. Create i18n property files (e.g., \`messagebundle.properties\`)
+2. Register your bundle with UI5 Web Components
+3. Use the hook to access translated texts
+
+## More Information
+
+For detailed i18n setup and usage, see:
+- Storybook: Knowledge Base > Internationalization
+- https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-internationalization--docs
+`;
+
+const USE_VIEWPORT_RANGE_DOCS = `# useViewportRange Hook
+
+Import: \`import { useViewportRange } from '@ui5/webcomponents-react-base/hooks';\`
+
+The useViewportRange hook is a utility based on Device.getCurrentRange() and Device.attachMediaHandler(). It always returns the name of the currently active responsive range.
+
+## Signature
+
+\`\`\`typescript
+function useViewportRange(): 'Phone' | 'Tablet' | 'Desktop' | 'LargeDesktop'
+\`\`\`
+
+## Usage
+
+\`\`\`tsx
+import { useViewportRange } from '@ui5/webcomponents-react-base/hooks';
+
+function MyResponsiveComponent() {
+  const currentRange = useViewportRange();
+
+  return (
+    <div>
+      <p>Current viewport: {currentRange}</p>
+      {currentRange === 'Phone' && <MobileLayout />}
+      {currentRange === 'Desktop' && <DesktopLayout />}
+    </div>
+  );
+}
+\`\`\`
+
+## Responsive Ranges
+
+- **Phone**: \`(max-width: 599px)\`
+- **Tablet**: \`(min-width: 600px) and (max-width: 1023px)\`
+- **Desktop**: \`(min-width: 1024px) and (max-width: 1439px)\`
+- **LargeDesktop**: \`(min-width: 1440px)\`
+
+## Benefits
+
+- Automatic re-render on range changes
+- Clean React hook API
+- Based on SAP Responsive Breakpoints
+- No manual event listener management needed
+
+## Example: Conditional Rendering
+
+\`\`\`tsx
+function AdaptiveTable() {
+  const range = useViewportRange();
+  const isMobile = range === 'Phone';
+
+  return isMobile ? <MobileTable /> : <DesktopTable />;
+}
+\`\`\`
+`;
+
+const WITH_WEB_COMPONENT_DOCS = `# withWebComponent
+
+⚠️ **Important**: Import from base package, not main package!
+
+**Correct Import**: \`import { withWebComponent } from '@ui5/webcomponents-react-base/withWebComponent';\`
+**Legacy Import**: \`import { withWebComponent } from '@ui5/webcomponents-react';\` (not recommended)
+
+## Purpose
+
+withWebComponent is an advanced utility for creating React wrappers around custom web components. This is typically only needed if you're:
+
+1. Creating wrappers for your own custom web components
+2. Wrapping third-party web components
+3. Contributing to the ui5-webcomponents-react library
+
+**Note**: You don't need this for using existing UI5 Web Components for React components - they're already wrapped!
+
+## Signature
+
+\`\`\`typescript
+function withWebComponent<T>(
+  Component: CustomElementConstructor,
+  options?: {
+    slots?: string[];
+    events?: string[];
+  }
+): React.ComponentType<T>
+\`\`\`
+
+## When to Use
+
+Use withWebComponent when you want to integrate a custom web component that:
+- Has shadow DOM
+- Uses custom events
+- Has slots for content projection
+- Needs React-style prop handling
+
+## Example
+
+\`\`\`tsx
+import { withWebComponent } from '@ui5/webcomponents-react-base/withWebComponent';
+import '@my-company/custom-components/dist/MyButton.js';
+
+// Wrap your custom web component
+export const MyButton = withWebComponent(
+  // @ts-ignore
+  window.customElements.get('my-button'),
+  {
+    slots: ['icon'],
+    events: ['click', 'custom-event']
+  }
+);
+
+// Now use it like a React component
+function App() {
+  return (
+    <MyButton
+      onClick={handleClick}
+      icon={<Icon />}
+    >
+      Click me
+    </MyButton>
+  );
+}
+\`\`\`
+
+## More Information
+
+For bringing your own web components, see:
+- Storybook: Knowledge Base > Bring Your Own Web Components
+- https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-bring-your-own-web-components--docs
+`;
+
+const ALL_UTILS_OVERVIEW = `# Public Utilities from @ui5/webcomponents-react-base
+
+⚠️ **Important**: Only use the utilities documented here. All other exports are intended for internal use and are not subject to semantic versioning!
+
+## Available Public APIs
+
+### 1. Device API
+\`import * as Device from '@ui5/webcomponents-react-base/Device';\`
+
+Device detection, responsive breakpoints, and event handlers for resize/orientation changes.
+
+### 2. ThemingParameters
+\`import { ThemingParameters } from '@ui5/webcomponents-react-base/ThemingParameters';\`
+
+JavaScript object with all CSS variables for theme-aware styling.
+
+### 3. useI18nBundle Hook
+\`import { useI18nBundle } from '@ui5/webcomponents-react-base/hooks';\`
+
+React hook for internationalization and translated text access.
+
+### 4. useViewportRange Hook
+\`import { useViewportRange } from '@ui5/webcomponents-react-base/hooks';\`
+
+React hook that returns the current responsive breakpoint.
+
+### 5. withWebComponent (Advanced)
+\`import { withWebComponent } from '@ui5/webcomponents-react-base/withWebComponent';\`
+
+Utility for wrapping custom web components in React. Import from base package!
+
+---
+
+## Quick Reference
+
+| Utility | Import | Use Case |
+|---------|--------|----------|
+| Device | \`@.../Device\` | Device detection, responsive handlers |
+| ThemingParameters | \`@.../ThemingParameters\` | Theme-aware colors and styles |
+| useI18nBundle | \`@.../hooks\` | Translations and i18n |
+| useViewportRange | \`@.../hooks\` | Responsive breakpoint detection |
+| withWebComponent | \`@.../withWebComponent\` | Wrap custom web components |
+
+## Documentation Links
+
+- Full documentation: https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-public-utils--docs
+- Internationalization guide: https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-internationalization--docs
+- Custom web components: https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-bring-your-own-web-components--docs
+
+Use \`get_public_utils\` with a specific \`name\` parameter to get detailed documentation for each utility.
+`;
+
+export const getPublicUtilsTool = {
+  name: 'get_public_utils',
+  title: 'Public Utilities & Hooks',
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description:
+    'Get documentation for public utilities and hooks from @ui5/webcomponents-react-base. ' +
+    'Covers Device API, ThemingParameters, useI18nBundle, useViewportRange, and withWebComponent.\n\n' +
+    'WHEN TO USE: You need to use device detection, theme-aware CSS variables in JS, internationalization hooks, responsive breakpoints, or wrap your own custom web components.\n' +
+    'DO NOT USE FOR: Looking up component props — use get_component_api. For general styling guidance — use get_documentation with section "Knowledge Base > Styling".\n' +
+    'LIMITS: Returns documentation for one utility per call, or an overview of all 5 utilities.\n\n' +
+    'EXAMPLE INPUT: { "name": "ThemingParameters" }\n' +
+    'EXAMPLE INPUT: { "name": "withWebComponent" }\n' +
+    'EXAMPLE INPUT: {} (returns overview of all utilities)',
+  inputSchema: {
+    name: z
+      .enum(['Device', 'ThemingParameters', 'useI18nBundle', 'useViewportRange', 'withWebComponent'])
+      .optional()
+      .describe('Specific utility/hook name. Omit to see all available utilities.'),
+  },
+  handler: ({ name }: GetPublicUtilsPayload) => {
+    try {
+      // If no name provided, return overview
+      if (!name) {
+        return createTextResponse(ALL_UTILS_OVERVIEW);
+      }
+
+      // Return specific documentation (validation happens at package installation time)
+      // We trust the enum constraint from inputSchema
+      switch (name) {
+        case 'Device':
+          return createTextResponse(DEVICE_DOCS);
+        case 'ThemingParameters':
+          return createTextResponse(THEMING_PARAMETERS_DOCS);
+        case 'useI18nBundle':
+          return createTextResponse(USE_I18N_BUNDLE_DOCS);
+        case 'useViewportRange':
+          return createTextResponse(USE_VIEWPORT_RANGE_DOCS);
+        case 'withWebComponent':
+          return createTextResponse(WITH_WEB_COMPONENT_DOCS);
+        default:
+          return createTextResponse(`Documentation for ${name} is not yet available. Please check back later.`);
+      }
+    } catch (error) {
+      return handleToolError(error, `Error getting documentation for ${name || 'public utils'}`);
+    }
+  },
+};
diff --git a/packages/mcp-server/src/tools/index.ts b/packages/mcp-server/src/tools/index.ts
new file mode 100644
index 00000000000..c02284a64d7
--- /dev/null
+++ b/packages/mcp-server/src/tools/index.ts
@@ -0,0 +1,4 @@
+export { getDocumentationTool } from './get_documentation/get_documentation.js';
+export { listComponentsTool } from './list_components/list_components.js';
+export { getComponentApiTool } from './get_component_api/get_component_api.js';
+export { getPublicUtilsTool } from './get_public_utils/get_public_utils.js';
diff --git a/packages/mcp-server/src/tools/list_components/descriptions.json b/packages/mcp-server/src/tools/list_components/descriptions.json
new file mode 100644
index 00000000000..2769ec359cd
--- /dev/null
+++ b/packages/mcp-server/src/tools/list_components/descriptions.json
@@ -0,0 +1,834 @@
+{
+  "components": {
+    "ActionSheet": {
+      "description": "The `ActionSheet` holds a list of buttons from which the user can select to complete an action.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "AnalyticalCardHeader": {
+      "description": "The `AnalyticalCardHeader` is a KPI header, enabling the AnalyticalCard representation.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "AnalyticalTable": {
+      "description": "The `AnalyticalTable` provides a set of convenient functions for responsive table design, including virtualization of rows and columns, infinite scrolling and customizable columns that will, unless otherwise defined, distribute the available space equally among themselves.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "FilterBar": {
+      "description": "The `FilterBar` displays filters in a user-friendly manner to populate values for a query.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "FilterGroupItem": {
+      "description": "Represents a filter belonging to the `FilterBar`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "FlexBox": {
+      "description": "The `FlexBox` builds the container for a flexible box layout by leveraging the CSS flexbox layout.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Grid": {
+      "description": "A layout container component used for aligning items with various sizes in a simple grid.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MessageBox": {
+      "description": "The `MessageBox` component provides easier methods to create a `Dialog`, such as standard alerts, confirmation dialogs, or arbitrary message dialogs.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MessageItem": {
+      "description": "A component used to hold different types of system messages inside the `MessageView` component.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MessageViewButton": {
+      "description": "The `MessageViewButton` can be used for opening a `Popover` containing the `MessageView` component.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Modals": {
+      "description": "Utility class for opening modals in an imperative way.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "NumericSideIndicator": {
+      "description": "Holds a set of side indicator attributes used in the AnalyticalCardHeader component.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ObjectPage": {
+      "description": "A component that allows apps to easily display information related to a business object.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ObjectPageAnchorBar": {
+      "description": "The `ObjectPageAnchorBar` bar contains the expand/collapse (expands or collapses the header content) and pin button (pins the content header).",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ObjectPageHeader": {
+      "description": "The `ObjectPageHeader` component is used to serve as header section of the `ObjectPage`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ObjectPageSection": {
+      "description": "Top-level information container of an `ObjectPage`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ObjectPageSubSection": {
+      "description": "Second-level information container of an `ObjectPage`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ObjectPageTitle": {
+      "description": "The `ObjectPageTitle` component is used to serve as title of the `ObjectPage`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ObjectStatus": {
+      "description": "Status information that can be either text with a value state, or an icon.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ResponsiveGridLayout": {
+      "description": "The Responsive Grid Layout positions UI elements in a multi-column flow layout.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SelectDialog": {
+      "description": "The SelectDialog enables users to filter a comprehensive list via a search field and to select one or more items.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SplitterElement": {
+      "description": "The `SplitterElement` holds the component of the content area.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SplitterLayout": {
+      "description": "A layout that contains several content areas.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ThemeProvider": {
+      "description": "In order to use `@ui5/webcomponents-react` you have to wrap your application's root component into the ThemeProvider.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "VariantItem": {
+      "description": "The `VariantItem` describes a variant/view of the `VariantManagement` component.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "VariantManagement": {
+      "description": "The VariantManagement can be used to manage variants (views).",
+      "package": "@ui5/webcomponents-react"
+    }
+  },
+  "webComponents": {
+    "Avatar": {
+      "description": "An image-like component that has different display options for representing images and icons in different shapes and sizes, depending on the use case....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "AvatarBadge": {
+      "description": "The `AvatarBadge` component is used to display a badge on top of `Avatar` component.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "AvatarGroup": {
+      "description": "Displays a group of avatars arranged horizontally.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Bar": {
+      "description": "The Bar is a container which is primarily used to hold titles, buttons and input elements and its design and functionality is the basis for page headers and footers.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "BarcodeScannerDialog": {
+      "description": "The `BarcodeScannerDialog` component provides barcode scanning functionality for all devices that support the `MediaDevices.getUserMedia()` native API.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Breadcrumbs": {
+      "description": "Enables users to navigate between items by providing a list of links to previous steps in the user's navigation path.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "BreadcrumbsItem": {
+      "description": "The `BreadcrumbsItem` component defines the content of an item in `Breadcrumbs`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "BusyIndicator": {
+      "description": "The `BusyIndicator` signals that some operation is going on and that the user must wait.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Button": {
+      "description": "The `Button` component represents a simple push button.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ButtonBadge": {
+      "description": "The `ButtonBadge` component defines a badge that appears in the `Button`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Calendar": {
+      "description": "The `Calendar` component allows users to select one or more dates....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "CalendarDate": {
+      "description": "The `Date` component defines a calendar date to be used inside `Calendar`...",
+      "package": "@ui5/webcomponents-react"
+    },
+    "CalendarDateRange": {
+      "description": "The `DateRange` component defines a range of dates to be used inside `Calendar`...",
+      "package": "@ui5/webcomponents-react"
+    },
+    "CalendarLegend": {
+      "description": "The `CalendarLegend` component is designed for use within the `Calendar` to display a legend.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "CalendarLegendItem": {
+      "description": "Each `CalendarLegendItem` represents a legend item, displaying a color with a label.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Card": {
+      "description": "The `Card` is a component that represents information in the form of a tile with separate header and content areas.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "CardHeader": {
+      "description": "The `CardHeader` is a component, meant to be used as a header of the `Card` component.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Carousel": {
+      "description": "The Carousel allows the user to browse through a set of items.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "CheckBox": {
+      "description": "Allows the user to set a binary value, such as true/false or yes/no for an item....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ColorPalette": {
+      "description": "The `ColorPalette` provides the users with a range of predefined colors.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ColorPaletteItem": {
+      "description": "The `ColorPaletteItem` component represents a color in the the `ColorPalette`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ColorPalettePopover": {
+      "description": "Represents a predefined range of colors for easier selection....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ColorPicker": {
+      "description": "The `ColorPicker` allows users to choose any color and provides different input options for selecting colors....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ComboBox": {
+      "description": "The `Combobox` component represents a drop-down menu with a list of the available options and a text input field to narrow down the options....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ComboBoxItem": {
+      "description": "The `CbItem` represents the item for a `Combobox`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ComboBoxItemGroup": {
+      "description": "The `CbGroupItem` is type of suggestion item, that can be used to split the `Combobox` suggestions into groups....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "DatePicker": {
+      "description": "The `DatePicker` component provides an input field with assigned calendar which opens on user action.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "DateRangePicker": {
+      "description": "The DateRangePicker enables the users to enter a localized date range using touch, mouse, keyboard input, or by selecting a date range in the calendar....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "DateTimePicker": {
+      "description": "The `DateTimePicker` component alows users to select both date (day, month and year) and time (hours, minutes and seconds) and for the purpose it consists of input field and Date/Time picker....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Dialog": {
+      "description": "The `Dialog` component is used to temporarily display some information in a size-limited window in front of the regular app screen.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "DynamicDateRange": {
+      "description": "The `DynamicDateRange` component provides a flexible interface to define date ranges using a combination of absolute dates, relative intervals, and preset ranges (e.g., \"Today\", \"Yesterday\", etc.).",
+      "package": "@ui5/webcomponents-react"
+    },
+    "DynamicPage": {
+      "description": "A layout component, representing a web page, consisting of a title, header with dynamic behavior, a content area, and an optional floating footer....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "DynamicPageHeader": {
+      "description": "Header of the DynamicPage....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "DynamicPageTitle": {
+      "description": "Title of the `DynamicPage`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "DynamicSideContent": {
+      "description": "The DynamicSideContent (`DynamicSideContent`) is a layout component that allows additional content to be displayed in a way that flexibly adapts to different screen sizes.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ExpandableText": {
+      "description": "The `ExpandableText` component allows displaying a large body of text in a small space.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "FileUploader": {
+      "description": "The `FileUploader` opens a file explorer dialog and enables users to upload files.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "FilterItem": {
+      "description": "The `FilterItem` component defines the filtering criteria for data in `ViewSettingsDialog`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "FilterItemOption": {
+      "description": "The `FilterItemOption` component defines individual filter values within a `FilterItem`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "FlexibleColumnLayout": {
+      "description": "The `FlexibleColumnLayout` implements the list-detail-detail paradigm by displaying up to three pages in separate columns.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Form": {
+      "description": "The Form is a layout component that arranges labels and form fields (like input fields) pairs into a specific number of columns....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "FormGroup": {
+      "description": "The FormGroup (FormGroup) represents a group inside the Form (Form) component and it consists of FormItem (FormItem) components....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "FormItem": {
+      "description": "The FormItem (FormItem) represents pair of a label and one or more components (text or text fields), associated to it....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "GroupItem": {
+      "description": "The `GroupItem` component defines the grouping criteria for data in `ViewSettingsDialog`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Icon": {
+      "description": "The `Icon` component represents an SVG icon.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "IllustratedMessage": {
+      "description": "An IllustratedMessage is a recommended combination of a solution-oriented message, an engaging illustration, and conversational tone to better communicate an empty or a success state than just show a ...",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Input": {
+      "description": "The `Input` component allows the user to enter and edit text or numeric values in one line....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Label": {
+      "description": "The `Label` is a component used to represent a label for elements like input, textarea, select.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Link": {
+      "description": "The `Link` is a hyperlink component that is used to navigate to other apps and web pages, or to trigger actions.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "List": {
+      "description": "The `List` component allows displaying a list of items, advanced keyboard handling support for navigating between items, and predefined modes to improve the development efficiency....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ListItemCustom": {
+      "description": "A component to be used as custom list item within the `List` the same way as the standard `Li`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ListItemGroup": {
+      "description": "The `LiGroup` is a special list item, used only to create groups of list items....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ListItemStandard": {
+      "description": "The `Li` represents the simplest type of item for a `List`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MediaGallery": {
+      "description": "The `MediaGallery` component allows the user to browse through multimedia items.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MediaGalleryItem": {
+      "description": "The `MediaGalleryItem` web component represents the items displayed in the `MediaGallery` web component....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Menu": {
+      "description": "`Menu` component represents a hierarchical menu structure....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MenuItem": {
+      "description": "`MenuItem` is the item to use inside a `Menu`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MenuItemGroup": {
+      "description": "The `MenuItemGroup` component represents a group of items designed for use inside a `Menu`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MenuSeparator": {
+      "description": "The `MenuSeparator` represents a horizontal line to separate menu items inside a `Menu`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MessageStrip": {
+      "description": "The MessageStrip component allows for the embedding of application-related messages.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MultiComboBox": {
+      "description": "The `MultiCombobox` component consists of a list box with items and a text field allowing the user to either type a value directly into the text field, or choose from the list of existing items....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MultiComboBoxItem": {
+      "description": "The `McbItem` represents the item for a `MultiCombobox`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MultiComboBoxItemGroup": {
+      "description": "The `McbItemGroup` is type of suggestion item, that can be used to split the `MultiCombobox` suggestions into groups....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "MultiInput": {
+      "description": "A `MultiInput` field allows the user to enter multiple values, which are displayed as `Token`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "NavigationLayout": {
+      "description": "The `NavigationLayout` is a container component that can be used to create a layout with a header, a side navigation and a content area....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "NotificationList": {
+      "description": "The `NotificationList` web component represents a container for `LiNotificationGroup` and `LiNotification`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "NotificationListGroupItem": {
+      "description": "The `LiNotificationGroup` is a special type of list item, that unlike others can group items within self, usually `LiNotification` items....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "NotificationListItem": {
+      "description": "The `LiNotification` is a type of list item, meant to display notifications....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Option": {
+      "description": "The `Option` component defines the content of an option in the `Select`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "OptionCustom": {
+      "description": "The `OptionCustom` component defines a custom content of an option in the `Select`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Page": {
+      "description": "The `Page` is a container component that holds one whole screen of an application.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Panel": {
+      "description": "The `Panel` component is a container which has a header and a content area and is used for grouping and displaying information.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Popover": {
+      "description": "The `Popover` component displays additional information for an object in a compact way and without leaving the page.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ProductSwitch": {
+      "description": "The `ProductSwitch` is an SAP Fiori specific web component that is used in `Shellbar` and allows the user to easily switch between products....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ProductSwitchItem": {
+      "description": "The `ProductSwitchItem` web component represents the items displayed in the `ProductSwitch` web component....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ProgressIndicator": {
+      "description": "Shows the progress of a process in a graphical way.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "RadioButton": {
+      "description": "The `RadioButton` component enables users to select a single option from a set of options.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "RangeSlider": {
+      "description": "Represents a numerical interval and two handles (grips) to select a sub-range within it.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "RatingIndicator": {
+      "description": "The Rating Indicator is used to display a specific number of icons that are used to rate an item.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ResponsivePopover": {
+      "description": "The `ResponsivePopover` acts as a Popover on desktop and tablet, while on phone it acts as a Dialog.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Search": {
+      "description": "A `Search` is an input with suggestions, used for user search....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SearchItem": {
+      "description": "A `SearchItem` is a list item, used for displaying search suggestions...",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SearchItemGroup": {
+      "description": "The `SearchItemGroup` is type of suggestion item, that can be used to split the `SearchItem` suggestions into groups....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SearchItemShowMore": {
+      "description": "A `SearchItemShowMore` is a special type of Li that acts as a button to progressively reveal additional (overflow) items within a group....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SearchMessageArea": {
+      "description": "`import \"@ui5/webcomponents-fiori/dist/SearchMessageArea.js\";`...",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SearchScope": {
+      "description": "The `SearchScope` represents the options for the scope in `Search`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SegmentedButton": {
+      "description": "The `SegmentedButton` shows a group of items.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SegmentedButtonItem": {
+      "description": "Users can use the `SegmentedButtonItem` as part of a `SegmentedButton`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Select": {
+      "description": "The `Select` component is used to create a drop-down list....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ShellBar": {
+      "description": "The `Shellbar` is meant to serve as an application header and includes numerous built-in features, such as: logo, profile image/icon, title, search field, notifications and so on....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ShellBarBranding": {
+      "description": "The `ShellbarBranding` component is intended to be placed inside the branding slot of the `Shellbar` component.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ShellBarItem": {
+      "description": "The `ShellbarItem` represents a custom item for `Shellbar`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ShellBarSearch": {
+      "description": "Search field for the ShellBar component....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ShellBarSpacer": {
+      "description": "The `ShellbarSpacer` is an element, used for visual separation between the two content parts of the `Shellbar`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SideNavigation": {
+      "description": "The `SideNavigation` is used as a standard menu in applications.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SideNavigationGroup": {
+      "description": "Represents a group of navigation actions within `SideNavigation`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SideNavigationItem": {
+      "description": "Represents a navigation action.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SideNavigationSubItem": {
+      "description": "Represents a single navigation action within `SideNavigationItem`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Slider": {
+      "description": "The Slider component represents a numerical range and a handle (grip).",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SortItem": {
+      "description": "The `SortItem` component defines the sorting criteria for data in `ViewSettingsDialog`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SpecialCalendarDate": {
+      "description": "The `SpecialDate` component defines a special calendar date to be used inside `Calendar`, which is visually distinguished from the rest of the dates....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SplitButton": {
+      "description": "`SplitButton` enables users to trigger actions.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "StepInput": {
+      "description": "The `StepInput` consists of an input field and buttons with icons to increase/decrease the value with the predefined step....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SuggestionItem": {
+      "description": "The `SuggestionItem` represents the suggestion item of the `Input`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SuggestionItemCustom": {
+      "description": "The `SuggestionItemCustom` is type of suggestion item, that can be used to place suggestion items with custom content in the input.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "SuggestionItemGroup": {
+      "description": "The `SuggestionItemGroup` is type of suggestion item, that can be used to split the `Input` suggestions into groups....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Switch": {
+      "description": "The `Switch` component is used for changing between binary states....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Tab": {
+      "description": "The `Tab` represents a selectable item inside a `Tabcontainer`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TabContainer": {
+      "description": "The `Tabcontainer` represents a collection of tabs with associated content.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TabSeparator": {
+      "description": "The `TabSeparator` represents a vertical line to separate tabs inside a `Tabcontainer`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Table": {
+      "description": "The `Table` component provides a set of sophisticated features for displaying and dealing with vast amounts of data in a responsive manner.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableCell": {
+      "description": "The `TableCell` represents a cell inside of a `Table`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableGrowing": {
+      "description": "The `TableGrowing` component is used inside the `Table` to add a growing/data loading functionalities to the table....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableHeaderCell": {
+      "description": "The `TableHeaderCell` component represents a column in the `Table`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableHeaderCellActionAI": {
+      "description": "The `TableHeaderCellActionAi` component defines a dedicated AI action for the table column....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableHeaderRow": {
+      "description": "The `TableHeaderRow` component represents the table headers of a `Table`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableRow": {
+      "description": "The `TableRow` component represents a row in the `Table`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableRowAction": {
+      "description": "The `TableRowAction` component defines an action for table rows....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableRowActionNavigation": {
+      "description": "The `TableRowActionNavigation` component defines a navigation action for table rows....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableSelection": {
+      "description": "The `TableSelection` component is used inside the `Table` to add key-based selection capabilities to the `Table`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableSelectionMulti": {
+      "description": "The `TableSelectionMulti` component is used inside the `Table` to add multi-selection capabilities to the `Table`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableSelectionSingle": {
+      "description": "The `TableSelectionSingle` component is used inside the `Table` to add single selection capabilities to the `Table`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TableVirtualizer": {
+      "description": "The `TableVirtualizer` component is used inside the `Table` to virtualize the table rows, if the `overflowMode` property of the table is set to 'Scroll'.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Tag": {
+      "description": "The `Tag` is a component which serves the purpose to attract the user attention to some piece of information (state, quantity, condition, etc.).",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Text": {
+      "description": "The `Text` component displays text that can be used in any content area of an application....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TextArea": {
+      "description": "The `Textarea` component is used to enter multiple rows of text....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TimePicker": {
+      "description": "The `TimePicker` component provides an input field with assigned clocks which are opened on user action.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Timeline": {
+      "description": "The `Timeline` component shows entries (such as objects, events, or posts) in chronological order.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TimelineGroupItem": {
+      "description": "An entry posted on the timeline.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TimelineItem": {
+      "description": "An entry posted on the timeline....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Title": {
+      "description": "The `Title` component is used to display titles inside a page.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Toast": {
+      "description": "The `Toast` is a small, non-disruptive popup for success or information messages that disappears automatically after a few seconds....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ToggleButton": {
+      "description": "The `ToggleButton` component is an enhanced `Button` that can be toggled between pressed and normal states.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Token": {
+      "description": "Tokens are small items of information (similar to tags) that mainly serve to visualize previously selected items....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Tokenizer": {
+      "description": "A `Tokenizer` is an invisible container for `Token`s that supports keyboard navigation and token selection....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Toolbar": {
+      "description": "The `Toolbar` component is used to create a horizontal layout with items.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ToolbarButton": {
+      "description": "The `ToolbarButton` represents an abstract action, used in the `Toolbar`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ToolbarItem": {
+      "description": "The `ToolbarItem` is a wrapper component used to integrate UI5 Web Components into the `Toolbar`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ToolbarSelect": {
+      "description": "The `ToolbarSelect` component is used to create a toolbar drop-down list.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ToolbarSelectOption": {
+      "description": "The `ToolbarSelectOption` component defines the content of an option in the `ToolbarSelect`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ToolbarSeparator": {
+      "description": "The `ToolbarSeparator` is an element, used for visual separation between two elements.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ToolbarSpacer": {
+      "description": "The `ToolbarSpacer` is an element, used for taking needed space for toolbar items to take 100% width.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Tree": {
+      "description": "The `Tree` component provides a tree structure for displaying data in a hierarchy....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TreeItem": {
+      "description": "The `TreeItem` represents a node in a tree structure, shown as a `List`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "TreeItemCustom": {
+      "description": "The `TreeItemCustom` represents a node in a tree structure, shown as a `List`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UploadCollection": {
+      "description": "This component allows you to represent files before uploading them to a server, with the help of `UploadCollectionItem`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UploadCollectionItem": {
+      "description": "A component to be used within the `UploadCollection`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UserMenu": {
+      "description": "The `UserMenu` is an SAP Fiori specific web component that is used in `Shellbar` and allows the user to easily see information and settings for the current user and all other logged in accounts....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UserMenuAccount": {
+      "description": "The `UserMenuAccount` represents an account in the `UserMenu`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UserMenuItem": {
+      "description": "`UserMenuItem` is the item to use inside a `UserMenu`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UserMenuItemGroup": {
+      "description": "The `UserMenuItemGroup` component represents a group of items designed for use inside a `UserMenu`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UserSettingsAccountView": {
+      "description": "The `UserSettingsAccountView` represents a view displayed in the `UserSettingsItem`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UserSettingsAppearanceView": {
+      "description": "The `UserSettingsAppearanceView` represents a view displayed in the `UserSettingsItem`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UserSettingsAppearanceViewGroup": {
+      "description": "The `UserSettingsAppearanceViewGroup` is a special list item group used to group appearance view items....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UserSettingsAppearanceViewItem": {
+      "description": "The `UserSettingsAppearanceViewItem` represents a theme/appearance option item within the `UserSettingsAppearanceView`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UserSettingsDialog": {
+      "description": "The `UserSettingsDialog` is an SAP Fiori-specific web component used in the `UserMenu`.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UserSettingsItem": {
+      "description": "The `UserSettingsItem` represents an item in the `UserSettingsDialog`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "UserSettingsView": {
+      "description": "The `UserSettingsView` represents a view displayed in the `UserSettingsItem`....",
+      "package": "@ui5/webcomponents-react"
+    },
+    "ViewSettingsDialog": {
+      "description": "The `ViewSettingsDialog` component helps the user to sort data within a list or a table.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "Wizard": {
+      "description": "The `Wizard` helps users to complete a complex task by dividing it into sections and guiding them through it.",
+      "package": "@ui5/webcomponents-react"
+    },
+    "WizardStep": {
+      "description": "A component that represents a logical step as part of the `Wizard`.",
+      "package": "@ui5/webcomponents-react"
+    }
+  },
+  "charts": {
+    "BarChart": {
+      "description": "A `BarChart` is a data visualization where each category is represented by a rectangle, with the width of the rectangle being proportional to the values being plotted.",
+      "package": "@ui5/webcomponents-react-charts"
+    },
+    "BulletChart": {
+      "description": "The `BulletChart` is used to compare primary and secondary (comparison) values.",
+      "package": "@ui5/webcomponents-react-charts"
+    },
+    "ColumnChart": {
+      "description": "A `ColumnChart` is a data visualization where each category is represented by a rectangle, with the height of the rectangle being proportional to the values being plotted.",
+      "package": "@ui5/webcomponents-react-charts"
+    },
+    "ColumnChartWithTrend": {
+      "description": "A `ColumnChartWithTrend` is a data visualization where each category is represented by a rectangle, with the height of the rectangle being proportional to the values being plotted amd a trend line...",
+      "package": "@ui5/webcomponents-react-charts"
+    },
+    "ComposedChart": {
+      "description": "The `ComposedChart` enables you to combine different chart types in one chart, e.g.",
+      "package": "@ui5/webcomponents-react-charts"
+    },
+    "DonutChart": {
+      "description": "A `DonutChart` is a type of graph that displays data in a circular graph with a cut-out hole in the middle.",
+      "package": "@ui5/webcomponents-react-charts"
+    },
+    "LineChart": {
+      "description": "A `LineChart` is a type of chart used to show information that changes over time - it connects multiple dots.",
+      "package": "@ui5/webcomponents-react-charts"
+    },
+    "PieChart": {
+      "description": "A Pie Chart is a type of graph that displays data in a circular graph.",
+      "package": "@ui5/webcomponents-react-charts"
+    },
+    "RadarChart": {
+      "description": "A radar or spider or web chart is a two-dimensional chart type designed to plot one or more series of values over multiple quantitative variables.",
+      "package": "@ui5/webcomponents-react-charts"
+    },
+    "RadialChart": {
+      "description": "Displays a ring chart highlighting a current status.",
+      "package": "@ui5/webcomponents-react-charts"
+    },
+    "ScatterChart": {
+      "description": "A `ScatterChart` is a data visualization that displays multiple circles (bubbles) in a two-dimensional plot.",
+      "package": "@ui5/webcomponents-react-charts"
+    },
+    "TimelineChart": {
+      "description": "> __Experimental Component!__ <br /> A `TimelineChart` is a data visualization chart that can be used to represent Gantt charts or any other timeline-based visualizations.",
+      "package": "@ui5/webcomponents-react-charts"
+    }
+  },
+  "ai": {
+    "Button": {
+      "description": "The `Button` component serves as a button for AI-related scenarios.",
+      "package": "@ui5/webcomponents-ai-react"
+    },
+    "ButtonState": {
+      "description": "`ButtonState` is the item to use for defining states of `Button` components....",
+      "package": "@ui5/webcomponents-ai-react"
+    },
+    "Input": {
+      "description": "The `Input` component extends the standard `Input` with **AI Writing Assistant** capabilities....",
+      "package": "@ui5/webcomponents-ai-react"
+    },
+    "PromptInput": {
+      "description": "The `PromptInput` component allows the user to write custom instructions in natural language, so that AI is guided to generate content tailored to user needs....",
+      "package": "@ui5/webcomponents-ai-react"
+    },
+    "TextArea": {
+      "description": "The `Textarea` component extends the standard TextArea with Writing Assistant capabilities.",
+      "package": "@ui5/webcomponents-ai-react"
+    }
+  },
+  "metadata": {
+    "version": "2.20.1",
+    "extractedAt": "2026-03-20T09:28:13.408Z",
+    "componentsCount": 26,
+    "webComponentsCount": 161,
+    "chartsCount": 12,
+    "aiCount": 5
+  }
+}
diff --git a/packages/mcp-server/src/tools/list_components/list_components.ts b/packages/mcp-server/src/tools/list_components/list_components.ts
new file mode 100644
index 00000000000..d661d6e772d
--- /dev/null
+++ b/packages/mcp-server/src/tools/list_components/list_components.ts
@@ -0,0 +1,195 @@
+/**
+ * @fileOverview list_components tool
+ * Lists all available UI5 Web Components for React components by category and package
+ */
+
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+import {
+  REACT_COMPONENT_CATEGORIES,
+  WEB_COMPONENT_CATEGORIES,
+  CHART_CATEGORIES,
+  AI_CATEGORIES,
+} from '../../utils/categories.js';
+import { createTextResponse, handleToolError } from '../../utils/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Type for component metadata
+type ComponentMetadata = {
+  description: string;
+  package?: string;
+};
+
+// Load extracted descriptions
+let DESCRIPTIONS: {
+  components: Record<string, string | ComponentMetadata>;
+  webComponents: Record<string, string | ComponentMetadata>;
+  charts: Record<string, string | ComponentMetadata>;
+  ai: Record<string, string | ComponentMetadata>;
+} = { components: {}, webComponents: {}, charts: {}, ai: {} };
+try {
+  const descriptionsPath = join(__dirname, 'descriptions.json');
+  DESCRIPTIONS = JSON.parse(readFileSync(descriptionsPath, 'utf-8'));
+} catch (error) {
+  console.warn('Could not load component descriptions:', error);
+}
+
+type ListComponentsPayload = {
+  category?: string;
+  package?: string;
+};
+
+const CHART_COMPONENTS = CHART_CATEGORIES.Charts;
+const AI_COMPONENTS = AI_CATEGORIES['AI Components'];
+
+// Web Components are the rest from the descriptions.webComponents object
+const WEB_COMPONENTS_CATEGORY = 'Web Components (Wrapped)';
+
+function formatComponentList(categoryFilter?: string, packageFilter?: string): string {
+  let output = '# UI5 Web Components for React - Component List\n\n';
+
+  const includeMain = !packageFilter || packageFilter === '@ui5/webcomponents-react';
+  const includeCharts = !packageFilter || packageFilter === '@ui5/webcomponents-react-charts';
+  const includeAI = !packageFilter || packageFilter === '@ui5/webcomponents-ai-react';
+
+  // React Components and Web Components from main package
+  if (includeMain) {
+    output += '## @ui5/webcomponents-react\n\n';
+
+    // Combine React and Web Component categories
+    const allCategories = ['Data Display', 'Layouts & Floorplans', 'Inputs', 'Modals & Popovers', 'User Feedback'];
+
+    for (const category of allCategories) {
+      if (categoryFilter && categoryFilter !== category && categoryFilter !== WEB_COMPONENTS_CATEGORY) continue;
+
+      // Check if we have any components in this category
+      const reactComponents = REACT_COMPONENT_CATEGORIES[category as keyof typeof REACT_COMPONENT_CATEGORIES] || [];
+      const webComponents = WEB_COMPONENT_CATEGORIES[category as keyof typeof WEB_COMPONENT_CATEGORIES] || [];
+
+      if (reactComponents.length === 0 && webComponents.length === 0) continue;
+
+      output += `### ${category}\n\n`;
+
+      // Show React components first
+      for (const name of reactComponents) {
+        const compData = DESCRIPTIONS.components[name];
+        const description = compData
+          ? typeof compData === 'string'
+            ? compData
+            : compData.description
+          : 'React component';
+        output += `- **${name}** _(React)_ - ${description}\n`;
+        output += `  \`\`\`tsx\n  import { ${name} } from '@ui5/webcomponents-react';\n  \`\`\`\n\n`;
+      }
+
+      // Then show Web Components in same category
+      if (!categoryFilter || categoryFilter === category || categoryFilter === WEB_COMPONENTS_CATEGORY) {
+        for (const name of webComponents) {
+          const wcData = DESCRIPTIONS.webComponents[name];
+          if (!wcData) continue;
+          const description = typeof wcData === 'string' ? wcData : wcData.description;
+          output += `- **${name}** _(Web Component)_ - ${description}\n`;
+          output += `  \`\`\`tsx\n  import { ${name} } from '@ui5/webcomponents-react';\n  \`\`\`\n\n`;
+        }
+      }
+    }
+
+    // Keep "Web Components (Wrapped)" category for full list
+    if (!categoryFilter || categoryFilter === WEB_COMPONENTS_CATEGORY) {
+      output += `### ${WEB_COMPONENTS_CATEGORY}\n\n`;
+      output += `All wrapped UI5 Web Components. Import from '@ui5/webcomponents-react'.\n\n`;
+
+      const wcNames = Object.keys(DESCRIPTIONS.webComponents).sort();
+      for (const name of wcNames) {
+        const wcData = DESCRIPTIONS.webComponents[name];
+        const description = typeof wcData === 'string' ? wcData : wcData.description;
+        output += `- **${name}** - ${description}\n`;
+      }
+      output += `\n**Total**: ${wcNames.length} Web Components\n\n`;
+    }
+  }
+
+  // Charts
+  if (includeCharts && (!categoryFilter || categoryFilter === 'Charts')) {
+    output += '## @ui5/webcomponents-react-charts\n\n';
+    output += '### Charts\n\n';
+    for (const name of CHART_COMPONENTS) {
+      const chartData = DESCRIPTIONS.charts[name];
+      const description = chartData
+        ? typeof chartData === 'string'
+          ? chartData
+          : chartData.description
+        : 'Chart component for data visualization';
+      output += `- **${name}** - ${description}\n`;
+      output += `  \`\`\`tsx\n  import { ${name} } from '@ui5/webcomponents-react-charts';\n  \`\`\`\n\n`;
+    }
+  }
+
+  // AI Components
+  if (includeAI && (!categoryFilter || categoryFilter === 'AI Components')) {
+    output += '## @ui5/webcomponents-ai-react\n\n';
+    output += '### AI Components\n\n';
+    for (const name of AI_COMPONENTS) {
+      const aiData = DESCRIPTIONS.ai[name];
+      const description = aiData ? (typeof aiData === 'string' ? aiData : aiData.description) : 'AI-enhanced component';
+      output += `- **${name}** - ${description}\n`;
+      output += `  \`\`\`tsx\n  import { ${name} } from '@ui5/webcomponents-ai-react';\n  \`\`\`\n\n`;
+    }
+  }
+
+  return output;
+}
+
+// ============================================================================
+// TOOL DEFINITION
+// ============================================================================
+
+export const listComponentsTool = {
+  name: 'list_components',
+  title: 'Browse Components',
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description:
+    'Browse all 203 available UI5 Web Components for React components across 4 packages with descriptions, categories, and import statements.\n\n' +
+    'WHEN TO USE: You need to discover which components exist, find the right component for a use case, or verify a component name before calling get_component_api.\n' +
+    'DO NOT USE FOR: Getting detailed props or methods — use get_component_api after finding the component name here.\n' +
+    'LIMITS: Returns all matching components at once (up to 203). Filter by category or package to reduce output size.\n\n' +
+    'EXAMPLE INPUT: { "category": "Inputs" }\n' +
+    'EXAMPLE INPUT: { "package": "@ui5/webcomponents-react-charts" }\n' +
+    'EXAMPLE INPUT: {} (returns all components)',
+  inputSchema: {
+    category: z
+      .enum([
+        'Data Display',
+        'Layouts & Floorplans',
+        'Inputs',
+        'Modals & Popovers',
+        'User Feedback',
+        'Charts',
+        'AI Components',
+        'Web Components (Wrapped)',
+      ])
+      .optional()
+      .describe('Filter components by category. Omit to show all categories.'),
+    package: z
+      .enum(['@ui5/webcomponents-react', '@ui5/webcomponents-react-charts', '@ui5/webcomponents-ai-react'])
+      .optional()
+      .describe('Filter components by npm package name. Omit to show all packages.'),
+  },
+  handler: ({ category, package: pkg }: ListComponentsPayload) => {
+    try {
+      const result = formatComponentList(category, pkg);
+      return createTextResponse(result);
+    } catch (error) {
+      return handleToolError(error, 'Error listing components');
+    }
+  },
+};
diff --git a/packages/mcp-server/src/types/cem.ts b/packages/mcp-server/src/types/cem.ts
new file mode 100644
index 00000000000..730359ed27e
--- /dev/null
+++ b/packages/mcp-server/src/types/cem.ts
@@ -0,0 +1,52 @@
+/**
+ * Custom Elements Manifest (CEM) types.
+ * Used by extract_component_descriptions.ts to enrich component API data
+ * with event details and CSS parts from the UI5 Web Components manifests.
+ *
+ * TODO: The CLI package (`@ui5/webcomponents-react-cli`) uses CEM types from
+ * the external `@ui5/webcomponents-tools` package. Consider sharing by either:
+ * - Adding a subpath export to the CLI package for its CEM utilities
+ * - Creating a shared internal package for CEM types and helpers
+ * See also: packages/cli/src/util/cem-reader.ts, packages/cli/src/util/formatters.ts
+ */
+
+export interface CemEventParam {
+  name: string;
+  type: { text: string };
+  description: string;
+  _ui5privacy?: string;
+}
+
+export interface CemEvent {
+  name: string;
+  description: string;
+  _ui5privacy?: string;
+  _ui5Cancelable?: boolean;
+  _ui5allowPreventDefault?: boolean;
+  _ui5Bubbles?: boolean;
+  _ui5parameters?: CemEventParam[];
+}
+
+export interface CemCssPart {
+  name: string;
+  description: string;
+}
+
+export interface CemDeclaration {
+  name?: string;
+  tagName?: string;
+  description?: string;
+  events?: CemEvent[];
+  cssParts?: CemCssPart[];
+  members?: unknown[];
+  slots?: unknown[];
+  superclass?: { name: string; package: string; module: string } | null;
+}
+
+export interface CemModule {
+  declarations?: CemDeclaration[];
+}
+
+export interface CemManifest {
+  modules?: CemModule[];
+}
diff --git a/packages/mcp-server/src/types/component-api.ts b/packages/mcp-server/src/types/component-api.ts
new file mode 100644
index 00000000000..3e4c8ddc07e
--- /dev/null
+++ b/packages/mcp-server/src/types/component-api.ts
@@ -0,0 +1,90 @@
+/**
+ * Component API types.
+ * Shared between extract_component_descriptions.ts (script) and get_component_api.ts (runtime).
+ */
+
+export interface TypeInfo {
+  name: string;
+  raw?: string;
+  value?: unknown;
+}
+
+export interface EventDetailParam {
+  name: string;
+  type: string;
+  description: string;
+}
+
+export interface EventDetail {
+  params: EventDetailParam[];
+  cancelable: boolean;
+  bubbles: boolean;
+}
+
+export interface CleanedProp {
+  type: TypeInfo;
+  required: boolean;
+  description: string;
+  defaultValue?: {
+    value: string;
+  };
+  eventDetail?: EventDetail;
+}
+
+export interface MethodParam {
+  name: string;
+  type: { name: string };
+  description: string;
+}
+
+export interface MethodInfo {
+  name: string;
+  description: string;
+  params: MethodParam[];
+  returns: {
+    type: string;
+  } | null;
+}
+
+export interface CssPart {
+  name: string;
+  description: string;
+}
+
+export interface ComponentApiData {
+  package: string;
+  description: string;
+  props: Record<string, CleanedProp>;
+  methods: MethodInfo[];
+  cssParts?: CssPart[];
+}
+
+export interface ComponentDescription {
+  description: string;
+  package: string;
+}
+
+export interface ApiMetadata {
+  version: string;
+  extractedAt: string;
+  componentsCount: number;
+  webComponentsCount: number;
+  chartsCount: number;
+  aiCount: number;
+}
+
+export interface DescriptionsStore {
+  components: Record<string, ComponentDescription>;
+  webComponents: Record<string, ComponentDescription>;
+  charts: Record<string, ComponentDescription>;
+  ai: Record<string, ComponentDescription>;
+  metadata?: ApiMetadata;
+}
+
+export interface ApiDataStore {
+  components: Record<string, ComponentApiData>;
+  webComponents: Record<string, ComponentApiData>;
+  charts: Record<string, ComponentApiData>;
+  ai: Record<string, ComponentApiData>;
+  metadata?: ApiMetadata;
+}
diff --git a/packages/mcp-server/src/types/documentation.ts b/packages/mcp-server/src/types/documentation.ts
new file mode 100644
index 00000000000..688b9c6f240
--- /dev/null
+++ b/packages/mcp-server/src/types/documentation.ts
@@ -0,0 +1,37 @@
+/**
+ * Documentation section types.
+ * Shared between bundle_docs.ts (script) and get_documentation.ts (runtime).
+ */
+
+export interface DocumentationSubsection {
+  name: string;
+  description: string;
+  link: string;
+  /** Monorepo-relative path to the source file (e.g., "docs/knowledge-base/Styling.mdx"). Used by bundle_docs.ts at build time. */
+  sourcePath?: string;
+  /** Monorepo-relative path to a JSON data source. When set, bundle_docs.ts generates LLM-friendly markdown from the data instead of copying the raw source file. */
+  dataSource?: string;
+  /** Flat filename in the bundled docs/ directory (e.g., "docs--knowledge-base--Styling.mdx"). Set by bundle_docs.ts, used at runtime. */
+  localPath?: string;
+  content: string[];
+  tags: string[];
+}
+
+export interface DocumentationSection {
+  name: string;
+  description: string;
+  link?: string;
+  /** Monorepo-relative path to the source file. Used by bundle_docs.ts at build time. */
+  sourcePath?: string;
+  /** Monorepo-relative path to a JSON data source. When set, bundle_docs.ts generates LLM-friendly markdown from the data instead of copying the raw source file. */
+  dataSource?: string;
+  /** Flat filename in the bundled docs/ directory. Set by bundle_docs.ts, used at runtime. */
+  localPath?: string;
+  content?: string[];
+  tags?: string[];
+  subsections?: DocumentationSubsection[];
+}
+
+export interface DocumentationData {
+  sections: DocumentationSection[];
+}
diff --git a/packages/mcp-server/src/types/index.ts b/packages/mcp-server/src/types/index.ts
new file mode 100644
index 00000000000..6588f923c24
--- /dev/null
+++ b/packages/mcp-server/src/types/index.ts
@@ -0,0 +1,18 @@
+export type { DocumentationSubsection, DocumentationSection, DocumentationData } from './documentation.js';
+
+export type {
+  TypeInfo,
+  EventDetailParam,
+  EventDetail,
+  CleanedProp,
+  MethodParam,
+  MethodInfo,
+  CssPart,
+  ComponentApiData,
+  ComponentDescription,
+  ApiMetadata,
+  DescriptionsStore,
+  ApiDataStore,
+} from './component-api.js';
+
+export type { CemEventParam, CemEvent, CemCssPart, CemDeclaration, CemModule, CemManifest } from './cem.js';
diff --git a/packages/mcp-server/src/utils/categories.ts b/packages/mcp-server/src/utils/categories.ts
new file mode 100644
index 00000000000..0cab64dcd32
--- /dev/null
+++ b/packages/mcp-server/src/utils/categories.ts
@@ -0,0 +1,218 @@
+/**
+ * Component categorization shared between list_components and extraction script
+ */
+
+export const REACT_COMPONENT_CATEGORIES = {
+  'Data Display': ['AnalyticalTable', 'AnalyticalCardHeader', 'ObjectStatus', 'NumericSideIndicator'],
+  'Layouts & Floorplans': [
+    'ObjectPage',
+    'ObjectPageSection',
+    'ObjectPageSubSection',
+    'ObjectPageTitle',
+    'ObjectPageHeader',
+    'ObjectPageAnchorBar',
+    'FlexBox',
+    'Grid',
+    'ResponsiveGridLayout',
+    'SplitterLayout',
+    'SplitterElement',
+    'Splitter',
+    'ThemeProvider',
+    'FilterBar',
+  ],
+  Inputs: ['FilterGroupItem', 'VariantManagement', 'VariantItem', 'MessageViewButton'],
+  'Modals & Popovers': ['MessageBox', 'ActionSheet', 'SelectDialog'],
+  'User Feedback': ['MessageView', 'MessageItem', 'Modals'],
+};
+
+export const WEB_COMPONENT_CATEGORIES = {
+  'Data Display': [
+    'Avatar',
+    'AvatarBadge',
+    'AvatarGroup',
+    'Card',
+    'CardHeader',
+    'ColorPalette',
+    'ColorPaletteItem',
+    'ExpandableText',
+    'Icon',
+    'Label',
+    'Link',
+    'List',
+    'ListItemStandard',
+    'ListItemCustom',
+    'ListItemGroup',
+    'MessageStrip',
+    'NotificationList',
+    'NotificationListItem',
+    'NotificationListGroupItem',
+    'ProgressIndicator',
+    'Table',
+    'TableRow',
+    'TableRowAction',
+    'TableRowActionNavigation',
+    'TableCell',
+    'TableHeaderRow',
+    'TableHeaderCell',
+    'TableHeaderCellActionAI',
+    'TableSelection',
+    'TableSelectionSingle',
+    'TableSelectionMulti',
+    'TableVirtualizer',
+    'TableGrowing',
+    'Tag',
+    'Text',
+    'Timeline',
+    'TimelineItem',
+    'TimelineGroupItem',
+    'Title',
+    'Tree',
+    'TreeItem',
+    'TreeItemCustom',
+  ],
+  Inputs: [
+    'Button',
+    'ButtonBadge',
+    'Calendar',
+    'CalendarDate',
+    'CalendarDateRange',
+    'CalendarLegend',
+    'CalendarLegendItem',
+    'CheckBox',
+    'ColorPicker',
+    'ComboBox',
+    'ComboBoxItem',
+    'ComboBoxItemGroup',
+    'DatePicker',
+    'DateRangePicker',
+    'DateTimePicker',
+    'DynamicDateRange',
+    'FileUploader',
+    'Input',
+    'MultiComboBox',
+    'MultiComboBoxItem',
+    'MultiComboBoxItemGroup',
+    'MultiInput',
+    'ProductSwitch',
+    'ProductSwitchItem',
+    'RadioButton',
+    'RangeSlider',
+    'RatingIndicator',
+    'Search',
+    'SearchScope',
+    'SearchItem',
+    'SearchItemGroup',
+    'SearchItemShowMore',
+    'SearchMessageArea',
+    'SegmentedButton',
+    'SegmentedButtonItem',
+    'Select',
+    'Option',
+    'OptionCustom',
+    'Slider',
+    'SpecialCalendarDate',
+    'SplitButton',
+    'StepInput',
+    'SuggestionItem',
+    'SuggestionItemCustom',
+    'SuggestionItemGroup',
+    'Switch',
+    'TextArea',
+    'TimePicker',
+    'ToggleButton',
+    'Token',
+    'Tokenizer',
+    'UploadCollection',
+    'UploadCollectionItem',
+  ],
+  'Layouts & Floorplans': [
+    'Bar',
+    'Breadcrumbs',
+    'BreadcrumbsItem',
+    'Carousel',
+    'DynamicPage',
+    'DynamicPageHeader',
+    'DynamicPageTitle',
+    'DynamicSideContent',
+    'FlexibleColumnLayout',
+    'Form',
+    'FormGroup',
+    'FormItem',
+    'MediaGallery',
+    'MediaGalleryItem',
+    'NavigationLayout',
+    'Page',
+    'Panel',
+    'ShellBar',
+    'ShellBarItem',
+    'ShellBarSpacer',
+    'ShellBarBranding',
+    'ShellBarSearch',
+    'SideNavigation',
+    'SideNavigationGroup',
+    'SideNavigationItem',
+    'SideNavigationSubItem',
+    'Tab',
+    'TabContainer',
+    'TabSeparator',
+    'Toolbar',
+    'ToolbarButton',
+    'ToolbarItem',
+    'ToolbarSelect',
+    'ToolbarSelectOption',
+    'ToolbarSeparator',
+    'ToolbarSpacer',
+    'Wizard',
+    'WizardStep',
+  ],
+  'Modals & Popovers': [
+    'BarcodeScannerDialog',
+    'ColorPalettePopover',
+    'Dialog',
+    'Menu',
+    'MenuItem',
+    'MenuItemGroup',
+    'MenuSeparator',
+    'Popover',
+    'ResponsivePopover',
+    'Toast',
+    'UserMenu',
+    'UserMenuAccount',
+    'UserMenuItem',
+    'UserMenuItemGroup',
+    'UserSettingsAccountView',
+    'UserSettingsAppearanceView',
+    'UserSettingsAppearanceViewGroup',
+    'UserSettingsAppearanceViewItem',
+    'UserSettingsDialog',
+    'UserSettingsItem',
+    'UserSettingsView',
+    'ViewSettingsDialog',
+    'FilterItem',
+    'FilterItemOption',
+    'GroupItem',
+    'SortItem',
+  ],
+  'User Feedback': ['BusyIndicator', 'IllustratedMessage'],
+};
+
+export const CHART_CATEGORIES = {
+  Charts: [
+    'BarChart',
+    'LineChart',
+    'ColumnChart',
+    'PieChart',
+    'DonutChart',
+    'RadialChart',
+    'RadarChart',
+    'ScatterChart',
+    'ComposedChart',
+    'BulletChart',
+    'ColumnChartWithTrend',
+    'TimelineChart',
+  ],
+};
+
+export const AI_CATEGORIES = {
+  'AI Components': ['Button', 'ButtonState', 'Input', 'PromptInput', 'TextArea'],
+};
diff --git a/packages/mcp-server/src/utils/index.ts b/packages/mcp-server/src/utils/index.ts
new file mode 100644
index 00000000000..e99840146a3
--- /dev/null
+++ b/packages/mcp-server/src/utils/index.ts
@@ -0,0 +1,28 @@
+/**
+ * Utility functions for the MCP server
+ */
+
+import { logger } from '../logger.js';
+
+/**
+ * Create a text response for MCP
+ */
+export function createTextResponse(text: string) {
+  return {
+    content: [
+      {
+        type: 'text' as const,
+        text,
+      },
+    ],
+  };
+}
+
+/**
+ * Handle tool errors consistently
+ */
+export function handleToolError(error: unknown, context: string) {
+  logger.error(context, error);
+  const message = error instanceof Error ? error.message : 'An unknown error occurred';
+  return createTextResponse(`Error: ${context}\n${message}`);
+}
diff --git a/packages/mcp-server/tsconfig.build.json b/packages/mcp-server/tsconfig.build.json
new file mode 100644
index 00000000000..fc8520e7376
--- /dev/null
+++ b/packages/mcp-server/tsconfig.build.json
@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig.json"
+}
diff --git a/packages/mcp-server/tsconfig.json b/packages/mcp-server/tsconfig.json
new file mode 100644
index 00000000000..94bf0394eeb
--- /dev/null
+++ b/packages/mcp-server/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "strict": true,
+    "types": ["node"],
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
diff --git a/tsconfig.build.json b/tsconfig.build.json
index 3faa9abf212..7d0573cbc04 100644
--- a/tsconfig.build.json
+++ b/tsconfig.build.json
@@ -21,6 +21,9 @@
     },
     {
       "path": "./packages/ai/tsconfig.build.json"
+    },
+    {
+      "path": "./packages/mcp-server/tsconfig.build.json"
     }
   ],
   "files": []
diff --git a/yarn.lock b/yarn.lock
index c1b3f90b088..8b82a00ff54 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1477,6 +1477,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/aix-ppc64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/aix-ppc64@npm:0.27.4"
+  conditions: os=aix & cpu=ppc64
+  languageName: node
+  linkType: hard
+
 "@esbuild/android-arm64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/android-arm64@npm:0.21.5"
@@ -1498,6 +1505,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/android-arm64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/android-arm64@npm:0.27.4"
+  conditions: os=android & cpu=arm64
+  languageName: node
+  linkType: hard
+
 "@esbuild/android-arm@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/android-arm@npm:0.21.5"
@@ -1519,6 +1533,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/android-arm@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/android-arm@npm:0.27.4"
+  conditions: os=android & cpu=arm
+  languageName: node
+  linkType: hard
+
 "@esbuild/android-x64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/android-x64@npm:0.21.5"
@@ -1540,6 +1561,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/android-x64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/android-x64@npm:0.27.4"
+  conditions: os=android & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@esbuild/darwin-arm64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/darwin-arm64@npm:0.21.5"
@@ -1561,6 +1589,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/darwin-arm64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/darwin-arm64@npm:0.27.4"
+  conditions: os=darwin & cpu=arm64
+  languageName: node
+  linkType: hard
+
 "@esbuild/darwin-x64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/darwin-x64@npm:0.21.5"
@@ -1582,6 +1617,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/darwin-x64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/darwin-x64@npm:0.27.4"
+  conditions: os=darwin & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@esbuild/freebsd-arm64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/freebsd-arm64@npm:0.21.5"
@@ -1603,6 +1645,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/freebsd-arm64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/freebsd-arm64@npm:0.27.4"
+  conditions: os=freebsd & cpu=arm64
+  languageName: node
+  linkType: hard
+
 "@esbuild/freebsd-x64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/freebsd-x64@npm:0.21.5"
@@ -1624,6 +1673,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/freebsd-x64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/freebsd-x64@npm:0.27.4"
+  conditions: os=freebsd & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@esbuild/linux-arm64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/linux-arm64@npm:0.21.5"
@@ -1645,6 +1701,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/linux-arm64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/linux-arm64@npm:0.27.4"
+  conditions: os=linux & cpu=arm64
+  languageName: node
+  linkType: hard
+
 "@esbuild/linux-arm@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/linux-arm@npm:0.21.5"
@@ -1666,6 +1729,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/linux-arm@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/linux-arm@npm:0.27.4"
+  conditions: os=linux & cpu=arm
+  languageName: node
+  linkType: hard
+
 "@esbuild/linux-ia32@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/linux-ia32@npm:0.21.5"
@@ -1687,6 +1757,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/linux-ia32@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/linux-ia32@npm:0.27.4"
+  conditions: os=linux & cpu=ia32
+  languageName: node
+  linkType: hard
+
 "@esbuild/linux-loong64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/linux-loong64@npm:0.21.5"
@@ -1708,6 +1785,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/linux-loong64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/linux-loong64@npm:0.27.4"
+  conditions: os=linux & cpu=loong64
+  languageName: node
+  linkType: hard
+
 "@esbuild/linux-mips64el@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/linux-mips64el@npm:0.21.5"
@@ -1729,6 +1813,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/linux-mips64el@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/linux-mips64el@npm:0.27.4"
+  conditions: os=linux & cpu=mips64el
+  languageName: node
+  linkType: hard
+
 "@esbuild/linux-ppc64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/linux-ppc64@npm:0.21.5"
@@ -1750,6 +1841,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/linux-ppc64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/linux-ppc64@npm:0.27.4"
+  conditions: os=linux & cpu=ppc64
+  languageName: node
+  linkType: hard
+
 "@esbuild/linux-riscv64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/linux-riscv64@npm:0.21.5"
@@ -1771,6 +1869,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/linux-riscv64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/linux-riscv64@npm:0.27.4"
+  conditions: os=linux & cpu=riscv64
+  languageName: node
+  linkType: hard
+
 "@esbuild/linux-s390x@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/linux-s390x@npm:0.21.5"
@@ -1792,6 +1897,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/linux-s390x@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/linux-s390x@npm:0.27.4"
+  conditions: os=linux & cpu=s390x
+  languageName: node
+  linkType: hard
+
 "@esbuild/linux-x64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/linux-x64@npm:0.21.5"
@@ -1813,6 +1925,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/linux-x64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/linux-x64@npm:0.27.4"
+  conditions: os=linux & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@esbuild/netbsd-arm64@npm:0.25.12":
   version: 0.25.12
   resolution: "@esbuild/netbsd-arm64@npm:0.25.12"
@@ -1827,6 +1946,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/netbsd-arm64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/netbsd-arm64@npm:0.27.4"
+  conditions: os=netbsd & cpu=arm64
+  languageName: node
+  linkType: hard
+
 "@esbuild/netbsd-x64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/netbsd-x64@npm:0.21.5"
@@ -1848,6 +1974,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/netbsd-x64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/netbsd-x64@npm:0.27.4"
+  conditions: os=netbsd & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@esbuild/openbsd-arm64@npm:0.25.12":
   version: 0.25.12
   resolution: "@esbuild/openbsd-arm64@npm:0.25.12"
@@ -1862,6 +1995,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/openbsd-arm64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/openbsd-arm64@npm:0.27.4"
+  conditions: os=openbsd & cpu=arm64
+  languageName: node
+  linkType: hard
+
 "@esbuild/openbsd-x64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/openbsd-x64@npm:0.21.5"
@@ -1883,6 +2023,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/openbsd-x64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/openbsd-x64@npm:0.27.4"
+  conditions: os=openbsd & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@esbuild/openharmony-arm64@npm:0.25.12":
   version: 0.25.12
   resolution: "@esbuild/openharmony-arm64@npm:0.25.12"
@@ -1897,6 +2044,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/openharmony-arm64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/openharmony-arm64@npm:0.27.4"
+  conditions: os=openharmony & cpu=arm64
+  languageName: node
+  linkType: hard
+
 "@esbuild/sunos-x64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/sunos-x64@npm:0.21.5"
@@ -1918,6 +2072,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/sunos-x64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/sunos-x64@npm:0.27.4"
+  conditions: os=sunos & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@esbuild/win32-arm64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/win32-arm64@npm:0.21.5"
@@ -1939,6 +2100,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/win32-arm64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/win32-arm64@npm:0.27.4"
+  conditions: os=win32 & cpu=arm64
+  languageName: node
+  linkType: hard
+
 "@esbuild/win32-ia32@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/win32-ia32@npm:0.21.5"
@@ -1960,6 +2128,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/win32-ia32@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/win32-ia32@npm:0.27.4"
+  conditions: os=win32 & cpu=ia32
+  languageName: node
+  linkType: hard
+
 "@esbuild/win32-x64@npm:0.21.5":
   version: 0.21.5
   resolution: "@esbuild/win32-x64@npm:0.21.5"
@@ -1981,6 +2156,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@esbuild/win32-x64@npm:0.27.4":
+  version: 0.27.4
+  resolution: "@esbuild/win32-x64@npm:0.27.4"
+  conditions: os=win32 & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@eslint-community/eslint-utils@npm:^4.2.0, @eslint-community/eslint-utils@npm:^4.4.0, @eslint-community/eslint-utils@npm:^4.8.0, @eslint-community/eslint-utils@npm:^4.9.1":
   version: 4.9.1
   resolution: "@eslint-community/eslint-utils@npm:4.9.1"
@@ -2125,6 +2307,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@hono/node-server@npm:^1.19.9":
+  version: 1.19.11
+  resolution: "@hono/node-server@npm:1.19.11"
+  peerDependencies:
+    hono: ^4
+  checksum: 10c0/34b1c29c249c5cd95469980b5c359370f3cbab49b3603f324a4afbf895d68b8d5485c71f1887769eabeb3499276c49e7102084234b4feb3853edb748aaa85f50
+  languageName: node
+  linkType: hard
+
 "@humanfs/core@npm:^0.19.1":
   version: 0.19.1
   resolution: "@humanfs/core@npm:0.19.1"
@@ -2428,6 +2619,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@isaacs/cliui@npm:^8.0.2":
+  version: 8.0.2
+  resolution: "@isaacs/cliui@npm:8.0.2"
+  dependencies:
+    string-width: "npm:^5.1.2"
+    string-width-cjs: "npm:string-width@^4.2.0"
+    strip-ansi: "npm:^7.0.1"
+    strip-ansi-cjs: "npm:strip-ansi@^6.0.1"
+    wrap-ansi: "npm:^8.1.0"
+    wrap-ansi-cjs: "npm:wrap-ansi@^7.0.0"
+  checksum: 10c0/b1bf42535d49f11dc137f18d5e4e63a28c5569de438a221c369483731e9dac9fb797af554e8bf02b6192d1e5eba6e6402cf93900c3d0ac86391d00d04876789e
+  languageName: node
+  linkType: hard
+
 "@isaacs/cliui@npm:^9.0.0":
   version: 9.0.0
   resolution: "@isaacs/cliui@npm:9.0.0"
@@ -2593,6 +2798,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@mapbox/node-pre-gyp@npm:^2.0.0":
+  version: 2.0.3
+  resolution: "@mapbox/node-pre-gyp@npm:2.0.3"
+  dependencies:
+    consola: "npm:^3.2.3"
+    detect-libc: "npm:^2.0.0"
+    https-proxy-agent: "npm:^7.0.5"
+    node-fetch: "npm:^2.6.7"
+    nopt: "npm:^8.0.0"
+    semver: "npm:^7.5.3"
+    tar: "npm:^7.4.0"
+  bin:
+    node-pre-gyp: bin/node-pre-gyp
+  checksum: 10c0/6243c60f0d7327772c679aad20f17bcbf771b362fb7fbf1ae6dcf8dd379bb852e5af26180ab1e987a75dffa7cd5445414dc47e2acbcfe820cb08374deebecbc3
+  languageName: node
+  linkType: hard
+
 "@mdx-js/react@npm:^3.0.0":
   version: 3.1.1
   resolution: "@mdx-js/react@npm:3.1.1"
@@ -2605,6 +2827,39 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@modelcontextprotocol/sdk@npm:^1.27.1":
+  version: 1.27.1
+  resolution: "@modelcontextprotocol/sdk@npm:1.27.1"
+  dependencies:
+    "@hono/node-server": "npm:^1.19.9"
+    ajv: "npm:^8.17.1"
+    ajv-formats: "npm:^3.0.1"
+    content-type: "npm:^1.0.5"
+    cors: "npm:^2.8.5"
+    cross-spawn: "npm:^7.0.5"
+    eventsource: "npm:^3.0.2"
+    eventsource-parser: "npm:^3.0.0"
+    express: "npm:^5.2.1"
+    express-rate-limit: "npm:^8.2.1"
+    hono: "npm:^4.11.4"
+    jose: "npm:^6.1.3"
+    json-schema-typed: "npm:^8.0.2"
+    pkce-challenge: "npm:^5.0.0"
+    raw-body: "npm:^3.0.0"
+    zod: "npm:^3.25 || ^4.0"
+    zod-to-json-schema: "npm:^3.25.1"
+  peerDependencies:
+    "@cfworker/json-schema": ^4.1.1
+    zod: ^3.25 || ^4.0
+  peerDependenciesMeta:
+    "@cfworker/json-schema":
+      optional: true
+    zod:
+      optional: false
+  checksum: 10c0/1b8ad87093c9e43174c7d65864b3d826a8dd050d5c32248f5da49fd72c51b556ebd702e3e49a7f1cc7fa25717a3f7fcee22ed89edd5bd3d8f4e1f8ca499b365e
+  languageName: node
+  linkType: hard
+
 "@napi-rs/wasm-runtime@npm:0.2.4":
   version: 0.2.4
   resolution: "@napi-rs/wasm-runtime@npm:0.2.4"
@@ -3279,6 +3534,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@pkgjs/parseargs@npm:^0.11.0":
+  version: 0.11.0
+  resolution: "@pkgjs/parseargs@npm:0.11.0"
+  checksum: 10c0/5bd7576bb1b38a47a7fc7b51ac9f38748e772beebc56200450c4a817d712232b8f1d3ef70532c80840243c657d491cf6a6be1e3a214cff907645819fdc34aadd
+  languageName: node
+  linkType: hard
+
 "@pkgr/core@npm:^0.2.9":
   version: 0.2.9
   resolution: "@pkgr/core@npm:0.2.9"
@@ -3345,7 +3607,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@rollup/pluginutils@npm:^5.0.2":
+"@rollup/pluginutils@npm:^5.0.2, @rollup/pluginutils@npm:^5.1.3":
   version: 5.3.0
   resolution: "@rollup/pluginutils@npm:5.3.0"
   dependencies:
@@ -3543,6 +3805,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@sap-theming/theming-base-content@npm:11.29.3":
+  version: 11.29.3
+  resolution: "@sap-theming/theming-base-content@npm:11.29.3"
+  checksum: 10c0/8da4e8c0dafce793fb410832534eebf1f35eb1eb15f55f030810cfd32a15d45778ead2b89b04418f4e187f62f4af5afacf9a8191a7b2d5b91253715878be058e
+  languageName: node
+  linkType: hard
+
 "@sap-theming/theming-base-content@npm:11.33.0":
   version: 11.33.0
   resolution: "@sap-theming/theming-base-content@npm:11.33.0"
@@ -3670,6 +3939,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@sindresorhus/merge-streams@npm:^2.1.0":
+  version: 2.3.0
+  resolution: "@sindresorhus/merge-streams@npm:2.3.0"
+  checksum: 10c0/69ee906f3125fb2c6bb6ec5cdd84e8827d93b49b3892bce8b62267116cc7e197b5cccf20c160a1d32c26014ecd14470a72a5e3ee37a58f1d6dadc0db1ccf3894
+  languageName: node
+  linkType: hard
+
 "@sindresorhus/merge-streams@npm:^4.0.0":
   version: 4.0.0
   resolution: "@sindresorhus/merge-streams@npm:4.0.0"
@@ -4434,6 +4710,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/node@npm:^22.10.0":
+  version: 22.19.15
+  resolution: "@types/node@npm:22.19.15"
+  dependencies:
+    undici-types: "npm:~6.21.0"
+  checksum: 10c0/f17eaf3d0d1da5e93ad9e287efb78201f8a5282973c004c5f70d91675c5c6b926a23acaa7b158a42b3d7e27e36b349d65a531710c91c308fca53dd7fa280ef98
+  languageName: node
+  linkType: hard
+
 "@types/normalize-package-data@npm:^2.4.0, @types/normalize-package-data@npm:^2.4.1":
   version: 2.4.4
   resolution: "@types/normalize-package-data@npm:2.4.4"
@@ -5117,6 +5402,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@ui5/webcomponents-base@npm:2.19.2":
+  version: 2.19.2
+  resolution: "@ui5/webcomponents-base@npm:2.19.2"
+  dependencies:
+    "@lit-labs/ssr-dom-shim": "npm:^1.1.2"
+    lit-html: "npm:^2.0.1"
+  checksum: 10c0/de4e73a5c557e91f3a005a3fd8983b5beac5e2e9d6016444a88d80bf6e66ea29c1828ccd64812b5f9c5f9535d34524458fd38bb6e4df09b1e08ce2c3fe66b5dd
+  languageName: node
+  linkType: hard
+
 "@ui5/webcomponents-base@npm:2.20.1":
   version: 2.20.1
   resolution: "@ui5/webcomponents-base@npm:2.20.1"
@@ -5172,6 +5467,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@ui5/webcomponents-icons-business-suite@npm:2.19.2":
+  version: 2.19.2
+  resolution: "@ui5/webcomponents-icons-business-suite@npm:2.19.2"
+  dependencies:
+    "@ui5/webcomponents-base": "npm:2.19.2"
+  checksum: 10c0/65c8cd799b322fafeafa248f1fdf53c2f237a3b1615e3aff3be7bba83c302cc2389d0d5799fe7478c4f530364f5f62bb45b1e6fef5e466032f062c911889f4b7
+  languageName: node
+  linkType: hard
+
 "@ui5/webcomponents-icons-business-suite@npm:2.20.1":
   version: 2.20.1
   resolution: "@ui5/webcomponents-icons-business-suite@npm:2.20.1"
@@ -5181,6 +5485,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@ui5/webcomponents-icons-tnt@npm:2.19.2":
+  version: 2.19.2
+  resolution: "@ui5/webcomponents-icons-tnt@npm:2.19.2"
+  dependencies:
+    "@ui5/webcomponents-base": "npm:2.19.2"
+  checksum: 10c0/20fe246f41ed6fdcd87cd3a1f64c8926935d9f354e65eb0baaf56ef4fc5cc32c0072b14b44a5647620b4e19d01df6dac1700ceb4a0e86e97865404b5f15edeb4
+  languageName: node
+  linkType: hard
+
 "@ui5/webcomponents-icons-tnt@npm:2.20.1":
   version: 2.20.1
   resolution: "@ui5/webcomponents-icons-tnt@npm:2.20.1"
@@ -5190,6 +5503,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@ui5/webcomponents-icons@npm:2.19.2":
+  version: 2.19.2
+  resolution: "@ui5/webcomponents-icons@npm:2.19.2"
+  dependencies:
+    "@ui5/webcomponents-base": "npm:2.19.2"
+  checksum: 10c0/fc37f54d601fc30eb3867085558ec56019ff2884fa9287aa0c51901112c2d5e643d5fb47ae708cc2b85c2f223c9db10d14d4b9ed8c8f4dd6d58ad5bdbf3a1b10
+  languageName: node
+  linkType: hard
+
 "@ui5/webcomponents-icons@npm:2.20.1":
   version: 2.20.1
   resolution: "@ui5/webcomponents-icons@npm:2.20.1"
@@ -5199,6 +5521,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@ui5/webcomponents-localization@npm:2.19.2":
+  version: 2.19.2
+  resolution: "@ui5/webcomponents-localization@npm:2.19.2"
+  dependencies:
+    "@types/openui5": "npm:^1.113.0"
+    "@ui5/webcomponents-base": "npm:2.19.2"
+  checksum: 10c0/65ea91adc281a544d68bf35ff103e6b813891100f75ea94acf27ca46061ecc04ae7a24cd81a236831b04162dc16342f7e65d4dcbbb8556bb99c445ac869345f6
+  languageName: node
+  linkType: hard
+
 "@ui5/webcomponents-localization@npm:2.20.1":
   version: 2.20.1
   resolution: "@ui5/webcomponents-localization@npm:2.20.1"
@@ -5274,7 +5606,26 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@ui5/webcomponents-react@workspace:packages/main":
+"@ui5/webcomponents-react-mcp@workspace:packages/mcp-server":
+  version: 0.0.0-use.local
+  resolution: "@ui5/webcomponents-react-mcp@workspace:packages/mcp-server"
+  dependencies:
+    "@modelcontextprotocol/sdk": "npm:^1.27.1"
+    "@types/node": "npm:^22.10.0"
+    "@ui5/webcomponents": "npm:2.19.2"
+    "@ui5/webcomponents-base": "npm:2.19.2"
+    "@ui5/webcomponents-react": "workspace:~"
+    ava: "npm:^6.4.1"
+    glob: "npm:^12.0.0"
+    react-docgen-typescript: "npm:^2.4.0"
+    tsx: "npm:^4.20.6"
+    zod: "npm:^3.25.76"
+  bin:
+    ui5-wcr-mcp: ./dist/index.js
+  languageName: unknown
+  linkType: soft
+
+"@ui5/webcomponents-react@workspace:packages/main, @ui5/webcomponents-react@workspace:~":
   version: 0.0.0-use.local
   resolution: "@ui5/webcomponents-react@workspace:packages/main"
   dependencies:
@@ -5305,6 +5656,16 @@ __metadata:
   languageName: unknown
   linkType: soft
 
+"@ui5/webcomponents-theming@npm:2.19.2":
+  version: 2.19.2
+  resolution: "@ui5/webcomponents-theming@npm:2.19.2"
+  dependencies:
+    "@sap-theming/theming-base-content": "npm:11.29.3"
+    "@ui5/webcomponents-base": "npm:2.19.2"
+  checksum: 10c0/2490f054f3c2a5714086a0bf85d434c3b1ec3fe1926a59df61f1871ce7e647106c7cfb6c7be9ba4778831848ae92cd44ace2b5e9a07bcb09f00e4b384f5cc5ad
+  languageName: node
+  linkType: hard
+
 "@ui5/webcomponents-theming@npm:2.20.1":
   version: 2.20.1
   resolution: "@ui5/webcomponents-theming@npm:2.20.1"
@@ -5378,6 +5739,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@ui5/webcomponents@npm:2.19.2":
+  version: 2.19.2
+  resolution: "@ui5/webcomponents@npm:2.19.2"
+  dependencies:
+    "@ui5/webcomponents-base": "npm:2.19.2"
+    "@ui5/webcomponents-icons": "npm:2.19.2"
+    "@ui5/webcomponents-icons-business-suite": "npm:2.19.2"
+    "@ui5/webcomponents-icons-tnt": "npm:2.19.2"
+    "@ui5/webcomponents-localization": "npm:2.19.2"
+    "@ui5/webcomponents-theming": "npm:2.19.2"
+  checksum: 10c0/0ca5fae571ad6a83bd2880eae4a065f7b2637e66080224c0091bba605d1b86cedb415890598c2259a85929609dd28fe623eacea1c8ca35075435a7b1ec1a2e0c
+  languageName: node
+  linkType: hard
+
 "@ui5/webcomponents@npm:2.20.1":
   version: 2.20.1
   resolution: "@ui5/webcomponents@npm:2.20.1"
@@ -5527,6 +5902,28 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@vercel/nft@npm:^0.29.4":
+  version: 0.29.4
+  resolution: "@vercel/nft@npm:0.29.4"
+  dependencies:
+    "@mapbox/node-pre-gyp": "npm:^2.0.0"
+    "@rollup/pluginutils": "npm:^5.1.3"
+    acorn: "npm:^8.6.0"
+    acorn-import-attributes: "npm:^1.9.5"
+    async-sema: "npm:^3.1.1"
+    bindings: "npm:^1.4.0"
+    estree-walker: "npm:2.0.2"
+    glob: "npm:^10.4.5"
+    graceful-fs: "npm:^4.2.9"
+    node-gyp-build: "npm:^4.2.2"
+    picomatch: "npm:^4.0.2"
+    resolve-from: "npm:^5.0.0"
+  bin:
+    nft: out/cli.js
+  checksum: 10c0/84ba32c685f9d7c2c849b1e8c963d3b7eb09d122e666143ed97c3776f5b04a4745605e1d29fd81383f72b1d1c0d7d58e39f06dc92f021b5de079dfa4e8523574
+  languageName: node
+  linkType: hard
+
 "@vitejs/plugin-react@npm:5.2.0":
   version: 5.2.0
   resolution: "@vitejs/plugin-react@npm:5.2.0"
@@ -6031,6 +6428,25 @@ __metadata:
   languageName: node
   linkType: hard
 
+"accepts@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "accepts@npm:2.0.0"
+  dependencies:
+    mime-types: "npm:^3.0.0"
+    negotiator: "npm:^1.0.0"
+  checksum: 10c0/98374742097e140891546076215f90c32644feacf652db48412329de4c2a529178a81aa500fbb13dd3e6cbf6e68d829037b123ac037fc9a08bcec4b87b358eef
+  languageName: node
+  linkType: hard
+
+"acorn-import-attributes@npm:^1.9.5":
+  version: 1.9.5
+  resolution: "acorn-import-attributes@npm:1.9.5"
+  peerDependencies:
+    acorn: ^8
+  checksum: 10c0/5926eaaead2326d5a86f322ff1b617b0f698aa61dc719a5baa0e9d955c9885cc71febac3fb5bacff71bbf2c4f9c12db2056883c68c53eb962c048b952e1e013d
+  languageName: node
+  linkType: hard
+
 "acorn-jsx@npm:^5.3.1, acorn-jsx@npm:^5.3.2":
   version: 5.3.2
   resolution: "acorn-jsx@npm:5.3.2"
@@ -6067,7 +6483,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"acorn@npm:^8.11.0, acorn@npm:^8.15.0, acorn@npm:^8.16.0":
+"acorn@npm:^8.11.0, acorn@npm:^8.15.0, acorn@npm:^8.16.0, acorn@npm:^8.6.0":
   version: 8.16.0
   resolution: "acorn@npm:8.16.0"
   bin:
@@ -6119,6 +6535,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"ajv-formats@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "ajv-formats@npm:3.0.1"
+  dependencies:
+    ajv: "npm:^8.0.0"
+  peerDependencies:
+    ajv: ^8.0.0
+  peerDependenciesMeta:
+    ajv:
+      optional: true
+  checksum: 10c0/168d6bca1ea9f163b41c8147bae537e67bd963357a5488a1eaf3abe8baa8eec806d4e45f15b10767e6020679315c7e1e5e6803088dfb84efa2b4e9353b83dd0a
+  languageName: node
+  linkType: hard
+
 "ajv@npm:^6.10.0, ajv@npm:^6.12.4, ajv@npm:^6.14.0":
   version: 6.14.0
   resolution: "ajv@npm:6.14.0"
@@ -6131,7 +6561,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ajv@npm:^8.0.1, ajv@npm:^8.12.0":
+"ajv@npm:^8.0.0, ajv@npm:^8.0.1, ajv@npm:^8.12.0, ajv@npm:^8.17.1":
   version: 8.18.0
   resolution: "ajv@npm:8.18.0"
   dependencies:
@@ -6221,7 +6651,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-styles@npm:^6.2.1, ansi-styles@npm:^6.2.3":
+"ansi-styles@npm:^6.0.0, ansi-styles@npm:^6.1.0, ansi-styles@npm:^6.2.1, ansi-styles@npm:^6.2.3":
   version: 6.2.3
   resolution: "ansi-styles@npm:6.2.3"
   checksum: 10c0/23b8a4ce14e18fb854693b95351e286b771d23d8844057ed2e7d083cd3e708376c3323707ec6a24365f7d7eda3ca00327fe04092e29e551499ec4c8b7bfac868
@@ -6375,6 +6805,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"array-find-index@npm:^1.0.1":
+  version: 1.0.2
+  resolution: "array-find-index@npm:1.0.2"
+  checksum: 10c0/86b9485c74ddd324feab807e10a6de3f9c1683856267236fac4bb4d4667ada6463e106db3f6c540ae6b720e0442b590ec701d13676df4c6af30ebf4da09b4f57
+  languageName: node
+  linkType: hard
+
 "array-flatten@npm:1.1.1":
   version: 1.1.1
   resolution: "array-flatten@npm:1.1.1"
@@ -6500,6 +6937,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"arrgv@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "arrgv@npm:1.0.2"
+  checksum: 10c0/7e6e782e6b749923ac7cbc4048ef6fe0844c4a59bfc8932fcd4c44566ba25eed46501f94dd7cf3c7297da88f3f599ca056bfb77d0c2484aebc92f04239f69124
+  languageName: node
+  linkType: hard
+
 "arrify@npm:^1.0.1":
   version: 1.0.1
   resolution: "arrify@npm:1.0.1"
@@ -6507,6 +6951,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"arrify@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "arrify@npm:3.0.0"
+  checksum: 10c0/2e26601b8486f29780f1f70f7ac05a226755814c2a3ab42e196748f650af1dc310cd575a11dd4b9841c70fd7460b2dd2b8fe6fb7a3375878e2660706efafa58e
+  languageName: node
+  linkType: hard
+
 "asn1@npm:~0.2.3":
   version: 0.2.6
   resolution: "asn1@npm:0.2.6"
@@ -6574,6 +7025,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"async-sema@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "async-sema@npm:3.1.1"
+  checksum: 10c0/a16da9f7f2dbdd00a969bf264b7ad331b59df3eac2b38f529b881c5cc8662594e68ed096d927ec2aabdc13454379cdc6d677bcdb0a3d2db338fb4be17957832b
+  languageName: node
+  linkType: hard
+
 "async@npm:^3.2.4, async@npm:^3.2.6":
   version: 3.2.6
   resolution: "async@npm:3.2.6"
@@ -6595,6 +7053,61 @@ __metadata:
   languageName: node
   linkType: hard
 
+"ava@npm:^6.4.1":
+  version: 6.4.1
+  resolution: "ava@npm:6.4.1"
+  dependencies:
+    "@vercel/nft": "npm:^0.29.4"
+    acorn: "npm:^8.15.0"
+    acorn-walk: "npm:^8.3.4"
+    ansi-styles: "npm:^6.2.1"
+    arrgv: "npm:^1.0.2"
+    arrify: "npm:^3.0.0"
+    callsites: "npm:^4.2.0"
+    cbor: "npm:^10.0.9"
+    chalk: "npm:^5.4.1"
+    chunkd: "npm:^2.0.1"
+    ci-info: "npm:^4.3.0"
+    ci-parallel-vars: "npm:^1.0.1"
+    cli-truncate: "npm:^4.0.0"
+    code-excerpt: "npm:^4.0.0"
+    common-path-prefix: "npm:^3.0.0"
+    concordance: "npm:^5.0.4"
+    currently-unhandled: "npm:^0.4.1"
+    debug: "npm:^4.4.1"
+    emittery: "npm:^1.2.0"
+    figures: "npm:^6.1.0"
+    globby: "npm:^14.1.0"
+    ignore-by-default: "npm:^2.1.0"
+    indent-string: "npm:^5.0.0"
+    is-plain-object: "npm:^5.0.0"
+    is-promise: "npm:^4.0.0"
+    matcher: "npm:^5.0.0"
+    memoize: "npm:^10.1.0"
+    ms: "npm:^2.1.3"
+    p-map: "npm:^7.0.3"
+    package-config: "npm:^5.0.0"
+    picomatch: "npm:^4.0.2"
+    plur: "npm:^5.1.0"
+    pretty-ms: "npm:^9.2.0"
+    resolve-cwd: "npm:^3.0.0"
+    stack-utils: "npm:^2.0.6"
+    strip-ansi: "npm:^7.1.0"
+    supertap: "npm:^3.0.1"
+    temp-dir: "npm:^3.0.0"
+    write-file-atomic: "npm:^6.0.0"
+    yargs: "npm:^17.7.2"
+  peerDependencies:
+    "@ava/typescript": "*"
+  peerDependenciesMeta:
+    "@ava/typescript":
+      optional: true
+  bin:
+    ava: entrypoints/cli.mjs
+  checksum: 10c0/21972df1031ef46533ea1b7daa132a5fc66841c8a221b6901163d12d2a1cac39bfd8a6d3459da7eb9344fa90fc02f237f2fe2aac8785d04bf5894fa43625be28
+  languageName: node
+  linkType: hard
+
 "available-typed-arrays@npm:^1.0.7":
   version: 1.0.7
   resolution: "available-typed-arrays@npm:1.0.7"
@@ -6761,6 +7274,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"bindings@npm:^1.4.0":
+  version: 1.5.0
+  resolution: "bindings@npm:1.5.0"
+  dependencies:
+    file-uri-to-path: "npm:1.0.0"
+  checksum: 10c0/3dab2491b4bb24124252a91e656803eac24292473e56554e35bbfe3cc1875332cfa77600c3bac7564049dc95075bf6fcc63a4609920ff2d64d0fe405fcf0d4ba
+  languageName: node
+  linkType: hard
+
 "bl@npm:^4.0.3, bl@npm:^4.1.0":
   version: 4.1.0
   resolution: "bl@npm:4.1.0"
@@ -6793,6 +7315,30 @@ __metadata:
   languageName: node
   linkType: hard
 
+"blueimp-md5@npm:^2.10.0":
+  version: 2.19.0
+  resolution: "blueimp-md5@npm:2.19.0"
+  checksum: 10c0/85d04343537dd99a288c62450341dcce7380d3454c81f8e5a971ddd80307d6f9ef51b5b92ad7d48aaaa92fd6d3a1f6b2f4fada068faae646887f7bfabc17a346
+  languageName: node
+  linkType: hard
+
+"body-parser@npm:^2.2.1":
+  version: 2.2.2
+  resolution: "body-parser@npm:2.2.2"
+  dependencies:
+    bytes: "npm:^3.1.2"
+    content-type: "npm:^1.0.5"
+    debug: "npm:^4.4.3"
+    http-errors: "npm:^2.0.0"
+    iconv-lite: "npm:^0.7.0"
+    on-finished: "npm:^2.4.1"
+    qs: "npm:^6.14.1"
+    raw-body: "npm:^3.0.1"
+    type-is: "npm:^2.0.1"
+  checksum: 10c0/95a830a003b38654b75166ca765358aa92ee3d561bf0e41d6ccdde0e1a0c9783cab6b90b20eb635d23172c010b59d3563a137a738e74da4ba714463510d05137
+  languageName: node
+  linkType: hard
+
 "body-parser@npm:~1.20.3":
   version: 1.20.4
   resolution: "body-parser@npm:1.20.4"
@@ -6837,7 +7383,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"brace-expansion@npm:^2.0.1":
+"brace-expansion@npm:^2.0.1, brace-expansion@npm:^2.0.2":
   version: 2.0.2
   resolution: "brace-expansion@npm:2.0.2"
   dependencies:
@@ -6926,7 +7472,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bytes@npm:~3.1.2":
+"bytes@npm:^3.1.2, bytes@npm:~3.1.2":
   version: 3.1.2
   resolution: "bytes@npm:3.1.2"
   checksum: 10c0/76d1c43cbd602794ad8ad2ae94095cddeb1de78c5dddaa7005c51af10b0176c69971a6d88e805a90c2b6550d76636e43c40d8427a808b8645ede885de4a0358e
@@ -7047,6 +7593,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"callsites@npm:^4.2.0":
+  version: 4.2.0
+  resolution: "callsites@npm:4.2.0"
+  checksum: 10c0/8f7e269ec09fc0946bb22d838a8bc7932e1909ab4a833b964749f4d0e8bdeaa1f253287c4f911f61781f09620b6925ccd19a5ea4897489c4e59442c660c312a3
+  languageName: node
+  linkType: hard
+
 "camelcase-keys@npm:^3.0.0":
   version: 3.0.0
   resolution: "camelcase-keys@npm:3.0.0"
@@ -7115,6 +7668,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"cbor@npm:^10.0.9":
+  version: 10.0.12
+  resolution: "cbor@npm:10.0.12"
+  dependencies:
+    nofilter: "npm:^3.0.2"
+  checksum: 10c0/4c197d783415cade31565725a5e6b2b967d856285eacdb0b5f5ec0687d93c12f2ee9c6cc05aa7be02e8bbf0fe3ba40d22be69b56bd2ab1be2cc0a59370f14246
+  languageName: node
+  linkType: hard
+
 "ccount@npm:^2.0.0":
   version: 2.0.1
   resolution: "ccount@npm:2.0.1"
@@ -7203,7 +7765,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"chalk@npm:^5.0.1":
+"chalk@npm:^5.0.1, chalk@npm:^5.4.1":
   version: 5.6.2
   resolution: "chalk@npm:5.6.2"
   checksum: 10c0/99a4b0f0e7991796b1e7e3f52dceb9137cae2a9dfc8fc0784a550dc4c558e15ab32ed70b14b21b52beb2679b4892b41a0aa44249bcb996f01e125d58477c6976
@@ -7353,6 +7915,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"chunkd@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "chunkd@npm:2.0.1"
+  checksum: 10c0/4e0c5aac6048ecedfa4cd0a5f6c4f010c70a7b7645aeca7bfeb47cb0733c3463054f0ced3f2667b2e0e67edd75d68a8e05481b01115ba3f8a952a93026254504
+  languageName: node
+  linkType: hard
+
 "ci-info@npm:4.3.1":
   version: 4.3.1
   resolution: "ci-info@npm:4.3.1"
@@ -7367,13 +7936,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ci-info@npm:^4.0.0, ci-info@npm:^4.1.0":
+"ci-info@npm:^4.0.0, ci-info@npm:^4.1.0, ci-info@npm:^4.3.0":
   version: 4.4.0
   resolution: "ci-info@npm:4.4.0"
   checksum: 10c0/44156201545b8dde01aa8a09ee2fe9fc7a73b1bef9adbd4606c9f61c8caeeb73fb7a575c88b0443f7b4edb5ee45debaa59ed54ba5f99698339393ca01349eb3a
   languageName: node
   linkType: hard
 
+"ci-parallel-vars@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "ci-parallel-vars@npm:1.0.1"
+  checksum: 10c0/80952f699cbbc146092b077b4f3e28d085620eb4e6be37f069b4dbb3db0ee70e8eec3beef4ebe70ff60631e9fc743b9d0869678489f167442cac08b260e5ac08
+  languageName: node
+  linkType: hard
+
 "clean-stack@npm:^2.0.0":
   version: 2.2.0
   resolution: "clean-stack@npm:2.2.0"
@@ -7445,6 +8021,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"cli-truncate@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "cli-truncate@npm:4.0.0"
+  dependencies:
+    slice-ansi: "npm:^5.0.0"
+    string-width: "npm:^7.0.0"
+  checksum: 10c0/d7f0b73e3d9b88cb496e6c086df7410b541b56a43d18ade6a573c9c18bd001b1c3fba1ad578f741a4218fdc794d042385f8ac02c25e1c295a2d8b9f3cb86eb4c
+  languageName: node
+  linkType: hard
+
 "cli-truncate@npm:^5.0.0":
   version: 5.2.0
   resolution: "cli-truncate@npm:5.2.0"
@@ -7539,6 +8125,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"code-excerpt@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "code-excerpt@npm:4.0.0"
+  dependencies:
+    convert-to-spaces: "npm:^2.0.1"
+  checksum: 10c0/b6c5a06e039cecd2ab6a0e10ee0831de8362107d1f298ca3558b5f9004cb8e0260b02dd6c07f57b9a0e346c76864d2873311ee1989809fdeb05bd5fbbadde773
+  languageName: node
+  linkType: hard
+
 "color-convert@npm:^1.9.0":
   version: 1.9.3
   resolution: "color-convert@npm:1.9.3"
@@ -7693,6 +8288,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"common-path-prefix@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "common-path-prefix@npm:3.0.0"
+  checksum: 10c0/c4a74294e1b1570f4a8ab435285d185a03976c323caa16359053e749db4fde44e3e6586c29cd051100335e11895767cbbd27ea389108e327d62f38daf4548fdb
+  languageName: node
+  linkType: hard
+
 "common-tags@npm:^1.8.0":
   version: 1.8.2
   resolution: "common-tags@npm:1.8.2"
@@ -7748,6 +8350,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"concordance@npm:^5.0.4":
+  version: 5.0.4
+  resolution: "concordance@npm:5.0.4"
+  dependencies:
+    date-time: "npm:^3.1.0"
+    esutils: "npm:^2.0.3"
+    fast-diff: "npm:^1.2.0"
+    js-string-escape: "npm:^1.0.1"
+    lodash: "npm:^4.17.15"
+    md5-hex: "npm:^3.0.1"
+    semver: "npm:^7.3.2"
+    well-known-symbols: "npm:^2.0.0"
+  checksum: 10c0/59b440f330df3a7c9aa148ba588b3e99aed86acab225b4f01ffcea34ace4cf11f817e31153254e8f38ed48508998dad40b9106951a743c334d751f7ab21afb8a
+  languageName: node
+  linkType: hard
+
 "confusing-browser-globals@npm:^1.0.10":
   version: 1.0.11
   resolution: "confusing-browser-globals@npm:1.0.11"
@@ -7755,6 +8373,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"consola@npm:^3.2.3":
+  version: 3.4.2
+  resolution: "consola@npm:3.4.2"
+  checksum: 10c0/7cebe57ecf646ba74b300bcce23bff43034ed6fbec9f7e39c27cee1dc00df8a21cd336b466ad32e304ea70fba04ec9e890c200270de9a526ce021ba8a7e4c11a
+  languageName: node
+  linkType: hard
+
 "console-control-strings@npm:^1.1.0":
   version: 1.1.0
   resolution: "console-control-strings@npm:1.1.0"
@@ -7769,6 +8394,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"content-disposition@npm:^1.0.0, content-disposition@npm:~1.0.1":
+  version: 1.0.1
+  resolution: "content-disposition@npm:1.0.1"
+  checksum: 10c0/bd7ff1fe8d2542d3a2b9a29428cc3591f6ac27bb5595bba2c69664408a68f9538b14cbd92479796ea835b317a09a527c8c7209c4200381dedb0c34d3b658849e
+  languageName: node
+  linkType: hard
+
 "content-disposition@npm:~0.5.4":
   version: 0.5.4
   resolution: "content-disposition@npm:0.5.4"
@@ -7778,13 +8410,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"content-disposition@npm:~1.0.1":
-  version: 1.0.1
-  resolution: "content-disposition@npm:1.0.1"
-  checksum: 10c0/bd7ff1fe8d2542d3a2b9a29428cc3591f6ac27bb5595bba2c69664408a68f9538b14cbd92479796ea835b317a09a527c8c7209c4200381dedb0c34d3b658849e
-  languageName: node
-  linkType: hard
-
 "content-type@npm:^1.0.5, content-type@npm:~1.0.4, content-type@npm:~1.0.5":
   version: 1.0.5
   resolution: "content-type@npm:1.0.5"
@@ -7899,6 +8524,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"convert-to-spaces@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "convert-to-spaces@npm:2.0.1"
+  checksum: 10c0/d90aa0e3b6a27f9d5265a8d32def3c5c855b3e823a9db1f26d772f8146d6b91020a2fdfd905ce8048a73fad3aaf836fef8188c67602c374405e2ae8396c4ac46
+  languageName: node
+  linkType: hard
+
+"cookie-signature@npm:^1.2.1":
+  version: 1.2.2
+  resolution: "cookie-signature@npm:1.2.2"
+  checksum: 10c0/54e05df1a293b3ce81589b27dddc445f462f6fa6812147c033350cd3561a42bc14481674e05ed14c7bd0ce1e8bb3dc0e40851bad75415733711294ddce0b7bc6
+  languageName: node
+  linkType: hard
+
 "cookie-signature@npm:~1.0.6":
   version: 1.0.7
   resolution: "cookie-signature@npm:1.0.7"
@@ -7906,7 +8545,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cookie@npm:~0.7.1":
+"cookie@npm:^0.7.1, cookie@npm:~0.7.1":
   version: 0.7.2
   resolution: "cookie@npm:0.7.2"
   checksum: 10c0/9596e8ccdbf1a3a88ae02cf5ee80c1c50959423e1022e4e60b91dd87c622af1da309253d8abdb258fb5e3eacb4f08e579dc58b4897b8087574eee0fd35dfa5d2
@@ -7946,6 +8585,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"cors@npm:^2.8.5":
+  version: 2.8.6
+  resolution: "cors@npm:2.8.6"
+  dependencies:
+    object-assign: "npm:^4"
+    vary: "npm:^1"
+  checksum: 10c0/ab2bc57b8af8ef8476682a59647f7c55c1a7d406b559ac06119aa1c5f70b96d35036864d197b24cf86e228e4547231088f1f94ca05061dbb14d89cc0bc9d4cab
+  languageName: node
+  linkType: hard
+
 "cosmiconfig@npm:9.0.0":
   version: 9.0.0
   resolution: "cosmiconfig@npm:9.0.0"
@@ -8013,7 +8662,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.1, cross-spawn@npm:^7.0.2, cross-spawn@npm:^7.0.3, cross-spawn@npm:^7.0.6":
+"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.1, cross-spawn@npm:^7.0.2, cross-spawn@npm:^7.0.3, cross-spawn@npm:^7.0.5, cross-spawn@npm:^7.0.6":
   version: 7.0.6
   resolution: "cross-spawn@npm:7.0.6"
   dependencies:
@@ -8180,6 +8829,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"currently-unhandled@npm:^0.4.1":
+  version: 0.4.1
+  resolution: "currently-unhandled@npm:0.4.1"
+  dependencies:
+    array-find-index: "npm:^1.0.1"
+  checksum: 10c0/32d197689ec32f035910202c1abb0dc6424dce01d7b51779c685119b380d98535c110ffff67a262fc7e367612a7dfd30d3d3055f9a6634b5a9dd1302de7ef11c
+  languageName: node
+  linkType: hard
+
 "custom-element-jet-brains-integration@npm:^1.4.4":
   version: 1.7.0
   resolution: "custom-element-jet-brains-integration@npm:1.7.0"
@@ -8400,6 +9058,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"date-time@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "date-time@npm:3.1.0"
+  dependencies:
+    time-zone: "npm:^1.0.0"
+  checksum: 10c0/aa3e2e930d74b0b9e90f69de7a16d3376e30f21f1f4ce9a2311d8fec32d760e776efea752dafad0ce188187265235229013036202be053fc2d7979813bfb6ded
+  languageName: node
+  linkType: hard
+
 "dateformat@npm:^3.0.3":
   version: 3.0.3
   resolution: "dateformat@npm:3.0.3"
@@ -8437,7 +9104,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"debug@npm:4, debug@npm:^4.0.0, debug@npm:^4.0.1, debug@npm:^4.1.0, debug@npm:^4.1.1, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.4, debug@npm:^4.3.5, debug@npm:^4.4.1, debug@npm:^4.4.3":
+"debug@npm:4, debug@npm:^4.0.0, debug@npm:^4.0.1, debug@npm:^4.1.0, debug@npm:^4.1.1, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.4, debug@npm:^4.3.5, debug@npm:^4.4.0, debug@npm:^4.4.1, debug@npm:^4.4.3":
   version: 4.4.3
   resolution: "debug@npm:4.4.3"
   dependencies:
@@ -8708,7 +9375,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"depd@npm:2.0.0, depd@npm:~2.0.0":
+"depd@npm:2.0.0, depd@npm:^2.0.0, depd@npm:~2.0.0":
   version: 2.0.0
   resolution: "depd@npm:2.0.0"
   checksum: 10c0/58bd06ec20e19529b06f7ad07ddab60e504d9e0faca4bd23079fac2d279c3594334d736508dc350e06e510aba5e22e4594483b3a6562ce7c17dd797f4cc4ad2c
@@ -8757,6 +9424,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"detect-libc@npm:^2.0.0":
+  version: 2.1.2
+  resolution: "detect-libc@npm:2.1.2"
+  checksum: 10c0/acc675c29a5649fa1fb6e255f993b8ee829e510b6b56b0910666949c80c364738833417d0edb5f90e4e46be17228b0f2b66a010513984e18b15deeeac49369c4
+  languageName: node
+  linkType: hard
+
 "devlop@npm:^1.0.0, devlop@npm:^1.1.0":
   version: 1.1.0
   resolution: "devlop@npm:1.1.0"
@@ -9089,6 +9763,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"emittery@npm:^1.2.0":
+  version: 1.2.1
+  resolution: "emittery@npm:1.2.1"
+  checksum: 10c0/188f6ee8725589df6d49a8ed18b216709dfda3574547860c122bc0223570d839bb2c8ca5cd95483a6b064636af195d7c6ab99a35a317f9734d8bc455f644c785
+  languageName: node
+  linkType: hard
+
 "emoji-regex@npm:^10.3.0":
   version: 10.6.0
   resolution: "emoji-regex@npm:10.6.0"
@@ -9620,6 +10301,95 @@ __metadata:
   languageName: node
   linkType: hard
 
+"esbuild@npm:~0.27.0":
+  version: 0.27.4
+  resolution: "esbuild@npm:0.27.4"
+  dependencies:
+    "@esbuild/aix-ppc64": "npm:0.27.4"
+    "@esbuild/android-arm": "npm:0.27.4"
+    "@esbuild/android-arm64": "npm:0.27.4"
+    "@esbuild/android-x64": "npm:0.27.4"
+    "@esbuild/darwin-arm64": "npm:0.27.4"
+    "@esbuild/darwin-x64": "npm:0.27.4"
+    "@esbuild/freebsd-arm64": "npm:0.27.4"
+    "@esbuild/freebsd-x64": "npm:0.27.4"
+    "@esbuild/linux-arm": "npm:0.27.4"
+    "@esbuild/linux-arm64": "npm:0.27.4"
+    "@esbuild/linux-ia32": "npm:0.27.4"
+    "@esbuild/linux-loong64": "npm:0.27.4"
+    "@esbuild/linux-mips64el": "npm:0.27.4"
+    "@esbuild/linux-ppc64": "npm:0.27.4"
+    "@esbuild/linux-riscv64": "npm:0.27.4"
+    "@esbuild/linux-s390x": "npm:0.27.4"
+    "@esbuild/linux-x64": "npm:0.27.4"
+    "@esbuild/netbsd-arm64": "npm:0.27.4"
+    "@esbuild/netbsd-x64": "npm:0.27.4"
+    "@esbuild/openbsd-arm64": "npm:0.27.4"
+    "@esbuild/openbsd-x64": "npm:0.27.4"
+    "@esbuild/openharmony-arm64": "npm:0.27.4"
+    "@esbuild/sunos-x64": "npm:0.27.4"
+    "@esbuild/win32-arm64": "npm:0.27.4"
+    "@esbuild/win32-ia32": "npm:0.27.4"
+    "@esbuild/win32-x64": "npm:0.27.4"
+  dependenciesMeta:
+    "@esbuild/aix-ppc64":
+      optional: true
+    "@esbuild/android-arm":
+      optional: true
+    "@esbuild/android-arm64":
+      optional: true
+    "@esbuild/android-x64":
+      optional: true
+    "@esbuild/darwin-arm64":
+      optional: true
+    "@esbuild/darwin-x64":
+      optional: true
+    "@esbuild/freebsd-arm64":
+      optional: true
+    "@esbuild/freebsd-x64":
+      optional: true
+    "@esbuild/linux-arm":
+      optional: true
+    "@esbuild/linux-arm64":
+      optional: true
+    "@esbuild/linux-ia32":
+      optional: true
+    "@esbuild/linux-loong64":
+      optional: true
+    "@esbuild/linux-mips64el":
+      optional: true
+    "@esbuild/linux-ppc64":
+      optional: true
+    "@esbuild/linux-riscv64":
+      optional: true
+    "@esbuild/linux-s390x":
+      optional: true
+    "@esbuild/linux-x64":
+      optional: true
+    "@esbuild/netbsd-arm64":
+      optional: true
+    "@esbuild/netbsd-x64":
+      optional: true
+    "@esbuild/openbsd-arm64":
+      optional: true
+    "@esbuild/openbsd-x64":
+      optional: true
+    "@esbuild/openharmony-arm64":
+      optional: true
+    "@esbuild/sunos-x64":
+      optional: true
+    "@esbuild/win32-arm64":
+      optional: true
+    "@esbuild/win32-ia32":
+      optional: true
+    "@esbuild/win32-x64":
+      optional: true
+  bin:
+    esbuild: bin/esbuild
+  checksum: 10c0/2a1c2bcccda279f2afd72a7f8259860cb4483b32453d17878e1ecb4ac416b9e7c1001e7aa0a25ba4c29c1e250a3ceaae5d8bb72a119815bc8db4e9b5f5321490
+  languageName: node
+  linkType: hard
+
 "escalade@npm:^3.1.1, escalade@npm:^3.2.0":
   version: 3.2.0
   resolution: "escalade@npm:3.2.0"
@@ -10131,21 +10901,21 @@ __metadata:
   languageName: node
   linkType: hard
 
-"estree-walker@npm:^2.0.2":
+"estree-walker@npm:2.0.2, estree-walker@npm:^2.0.2":
   version: 2.0.2
   resolution: "estree-walker@npm:2.0.2"
   checksum: 10c0/53a6c54e2019b8c914dc395890153ffdc2322781acf4bd7d1a32d7aedc1710807bdcd866ac133903d5629ec601fbb50abe8c2e5553c7f5a0afdd9b6af6c945af
   languageName: node
   linkType: hard
 
-"esutils@npm:^2.0.2":
+"esutils@npm:^2.0.2, esutils@npm:^2.0.3":
   version: 2.0.3
   resolution: "esutils@npm:2.0.3"
   checksum: 10c0/9a2fe69a41bfdade834ba7c42de4723c97ec776e40656919c62cbd13607c45e127a003f05f724a1ea55e5029a4cf2de444b13009f2af71271e42d93a637137c7
   languageName: node
   linkType: hard
 
-"etag@npm:~1.8.1":
+"etag@npm:^1.8.1, etag@npm:~1.8.1":
   version: 1.8.1
   resolution: "etag@npm:1.8.1"
   checksum: 10c0/12be11ef62fb9817314d790089a0a49fae4e1b50594135dcb8076312b7d7e470884b5100d249b28c18581b7fd52f8b485689ffae22a11ed9ec17377a33a08f84
@@ -10173,6 +10943,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"eventsource-parser@npm:^3.0.0, eventsource-parser@npm:^3.0.1":
+  version: 3.0.6
+  resolution: "eventsource-parser@npm:3.0.6"
+  checksum: 10c0/70b8ccec7dac767ef2eca43f355e0979e70415701691382a042a2df8d6a68da6c2fca35363669821f3da876d29c02abe9b232964637c1b6635c940df05ada78a
+  languageName: node
+  linkType: hard
+
+"eventsource@npm:^3.0.2":
+  version: 3.0.7
+  resolution: "eventsource@npm:3.0.7"
+  dependencies:
+    eventsource-parser: "npm:^3.0.1"
+  checksum: 10c0/c48a73c38f300e33e9f11375d4ee969f25cbb0519608a12378a38068055ae8b55b6e0e8a49c3f91c784068434efe1d9f01eb49b6315b04b0da9157879ce2f67d
+  languageName: node
+  linkType: hard
+
 "execa@npm:4.1.0":
   version: 4.1.0
   resolution: "execa@npm:4.1.0"
@@ -10266,6 +11052,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"express-rate-limit@npm:^8.2.1":
+  version: 8.3.1
+  resolution: "express-rate-limit@npm:8.3.1"
+  dependencies:
+    ip-address: "npm:10.1.0"
+  peerDependencies:
+    express: ">= 4.11"
+  checksum: 10c0/e3229938457cec617460c54ef4e90c8c254facc884729325d20ea35e3838bd273e4c611fc1f4a76f6d14c411e30d31b15e88eb4be87408615ff0aacc142511a2
+  languageName: node
+  linkType: hard
+
 "express@npm:^4.14.0":
   version: 4.22.1
   resolution: "express@npm:4.22.1"
@@ -10305,6 +11102,42 @@ __metadata:
   languageName: node
   linkType: hard
 
+"express@npm:^5.2.1":
+  version: 5.2.1
+  resolution: "express@npm:5.2.1"
+  dependencies:
+    accepts: "npm:^2.0.0"
+    body-parser: "npm:^2.2.1"
+    content-disposition: "npm:^1.0.0"
+    content-type: "npm:^1.0.5"
+    cookie: "npm:^0.7.1"
+    cookie-signature: "npm:^1.2.1"
+    debug: "npm:^4.4.0"
+    depd: "npm:^2.0.0"
+    encodeurl: "npm:^2.0.0"
+    escape-html: "npm:^1.0.3"
+    etag: "npm:^1.8.1"
+    finalhandler: "npm:^2.1.0"
+    fresh: "npm:^2.0.0"
+    http-errors: "npm:^2.0.0"
+    merge-descriptors: "npm:^2.0.0"
+    mime-types: "npm:^3.0.0"
+    on-finished: "npm:^2.4.1"
+    once: "npm:^1.4.0"
+    parseurl: "npm:^1.3.3"
+    proxy-addr: "npm:^2.0.7"
+    qs: "npm:^6.14.0"
+    range-parser: "npm:^1.2.1"
+    router: "npm:^2.2.0"
+    send: "npm:^1.1.0"
+    serve-static: "npm:^2.2.0"
+    statuses: "npm:^2.0.1"
+    type-is: "npm:^2.0.1"
+    vary: "npm:^1.1.2"
+  checksum: 10c0/45e8c841ad188a41402ddcd1294901e861ee0819f632fb494f2ed344ef9c43315d294d443fb48d594e6586a3b779785120f43321417adaef8567316a55072949
+  languageName: node
+  linkType: hard
+
 "extend@npm:^3.0.0, extend@npm:~3.0.2":
   version: 3.0.2
   resolution: "extend@npm:3.0.2"
@@ -10375,7 +11208,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fast-diff@npm:^1.1.2":
+"fast-diff@npm:^1.1.2, fast-diff@npm:^1.2.0":
   version: 1.3.0
   resolution: "fast-diff@npm:1.3.0"
   checksum: 10c0/5c19af237edb5d5effda008c891a18a585f74bf12953be57923f17a3a4d0979565fc64dbc73b9e20926b9d895f5b690c618cbb969af0cf022e3222471220ad29
@@ -10389,7 +11222,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fast-glob@npm:^3.1.1, fast-glob@npm:^3.2.7, fast-glob@npm:^3.2.9, fast-glob@npm:^3.3.0":
+"fast-glob@npm:^3.1.1, fast-glob@npm:^3.2.7, fast-glob@npm:^3.2.9, fast-glob@npm:^3.3.0, fast-glob@npm:^3.3.3":
   version: 3.3.3
   resolution: "fast-glob@npm:3.3.3"
   dependencies:
@@ -10489,6 +11322,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"file-uri-to-path@npm:1.0.0":
+  version: 1.0.0
+  resolution: "file-uri-to-path@npm:1.0.0"
+  checksum: 10c0/3b545e3a341d322d368e880e1c204ef55f1d45cdea65f7efc6c6ce9e0c4d22d802d5629320eb779d006fe59624ac17b0e848d83cc5af7cd101f206cb704f5519
+  languageName: node
+  linkType: hard
+
 "filelist@npm:^1.0.4":
   version: 1.0.6
   resolution: "filelist@npm:1.0.6"
@@ -10507,6 +11347,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"finalhandler@npm:^2.1.0":
+  version: 2.1.1
+  resolution: "finalhandler@npm:2.1.1"
+  dependencies:
+    debug: "npm:^4.4.0"
+    encodeurl: "npm:^2.0.0"
+    escape-html: "npm:^1.0.3"
+    on-finished: "npm:^2.4.1"
+    parseurl: "npm:^1.3.3"
+    statuses: "npm:^2.0.1"
+  checksum: 10c0/6bd664e21b7b2e79efcaace7d1a427169f61cce048fae68eb56290e6934e676b78e55d89f5998c5508871345bc59a61f47002dc505dc7288be68cceac1b701e2
+  languageName: node
+  linkType: hard
+
 "finalhandler@npm:~1.3.1":
   version: 1.3.2
   resolution: "finalhandler@npm:1.3.2"
@@ -10542,6 +11396,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"find-up-simple@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "find-up-simple@npm:1.0.1"
+  checksum: 10c0/ad34de157b7db925d50ff78302fefb28e309f3bc947c93ffca0f9b0bccf9cf1a2dc57d805d5c94ec9fc60f4838f5dbdfd2a48ecd77c23015fa44c6dd5f60bc40
+  languageName: node
+  linkType: hard
+
 "find-up@npm:^1.0.0":
   version: 1.1.2
   resolution: "find-up@npm:1.1.2"
@@ -10666,7 +11527,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"foreground-child@npm:^3.3.0, foreground-child@npm:^3.3.1":
+"foreground-child@npm:^3.1.0, foreground-child@npm:^3.3.0, foreground-child@npm:^3.3.1":
   version: 3.3.1
   resolution: "foreground-child@npm:3.3.1"
   dependencies:
@@ -10703,6 +11564,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"fresh@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "fresh@npm:2.0.0"
+  checksum: 10c0/0557548194cb9a809a435bf92bcfbc20c89e8b5eb38861b73ced36750437251e39a111fc3a18b98531be9dd91fe1411e4969f229dc579ec0251ce6c5d4900bbc
+  languageName: node
+  linkType: hard
+
 "fresh@npm:~0.5.2":
   version: 0.5.2
   resolution: "fresh@npm:0.5.2"
@@ -11019,7 +11887,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"get-tsconfig@npm:^4.10.1":
+"get-tsconfig@npm:^4.10.1, get-tsconfig@npm:^4.7.5":
   version: 4.13.6
   resolution: "get-tsconfig@npm:4.13.6"
   dependencies:
@@ -11159,6 +12027,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"glob@npm:^10.4.5":
+  version: 10.5.0
+  resolution: "glob@npm:10.5.0"
+  dependencies:
+    foreground-child: "npm:^3.1.0"
+    jackspeak: "npm:^3.1.2"
+    minimatch: "npm:^9.0.4"
+    minipass: "npm:^7.1.2"
+    package-json-from-dist: "npm:^1.0.0"
+    path-scurry: "npm:^1.11.1"
+  bin:
+    glob: dist/esm/bin.mjs
+  checksum: 10c0/100705eddbde6323e7b35e1d1ac28bcb58322095bd8e63a7d0bef1a2cdafe0d0f7922a981b2b48369a4f8c1b077be5c171804534c3509dfe950dde15fbe6d828
+  languageName: node
+  linkType: hard
+
 "glob@npm:^11.0.3":
   version: 11.1.0
   resolution: "glob@npm:11.1.0"
@@ -11175,6 +12059,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"glob@npm:^12.0.0":
+  version: 12.0.0
+  resolution: "glob@npm:12.0.0"
+  dependencies:
+    foreground-child: "npm:^3.3.1"
+    jackspeak: "npm:^4.1.1"
+    minimatch: "npm:^10.1.1"
+    minipass: "npm:^7.1.2"
+    package-json-from-dist: "npm:^1.0.0"
+    path-scurry: "npm:^2.0.0"
+  bin:
+    glob: dist/esm/bin.mjs
+  checksum: 10c0/923fbb7e30913496dc1c30191edb7ebb610a26edac81710a5f697c718b08694bce7fb0245baceba5383472778a8431ff7c36571703507cc6563602d3c139c993
+  languageName: node
+  linkType: hard
+
 "glob@npm:^7.1.3, glob@npm:^7.1.4, glob@npm:^7.1.6, glob@npm:^7.2.0, glob@npm:^7.2.3":
   version: 7.2.3
   resolution: "glob@npm:7.2.3"
@@ -11320,6 +12220,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"globby@npm:^14.1.0":
+  version: 14.1.0
+  resolution: "globby@npm:14.1.0"
+  dependencies:
+    "@sindresorhus/merge-streams": "npm:^2.1.0"
+    fast-glob: "npm:^3.3.3"
+    ignore: "npm:^7.0.3"
+    path-type: "npm:^6.0.0"
+    slash: "npm:^5.1.0"
+    unicorn-magic: "npm:^0.3.0"
+  checksum: 10c0/527a1063c5958255969620c6fa4444a2b2e9278caddd571d46dfbfa307cb15977afb746e84d682ba5b6c94fc081e8997f80ff05dd235441ba1cb16f86153e58e
+  languageName: node
+  linkType: hard
+
 "globrex@npm:^0.1.2":
   version: 0.1.2
   resolution: "globrex@npm:0.1.2"
@@ -11637,6 +12551,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"hono@npm:^4.11.4":
+  version: 4.12.8
+  resolution: "hono@npm:4.12.8"
+  checksum: 10c0/10b8a5012e362824d97d0f11895da6e7ba3195320399684f07b3743801986647aeb8395f189a8fefbe8d4567f943c23dc0ba73834ce9a848640a5d37d50f29b6
+  languageName: node
+  linkType: hard
+
 "hosted-git-info@npm:^2.1.4":
   version: 2.8.9
   resolution: "hosted-git-info@npm:2.8.9"
@@ -11702,7 +12623,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"http-errors@npm:^2.0.0, http-errors@npm:~2.0.0, http-errors@npm:~2.0.1":
+"http-errors@npm:^2.0.0, http-errors@npm:^2.0.1, http-errors@npm:~2.0.0, http-errors@npm:~2.0.1":
   version: 2.0.1
   resolution: "http-errors@npm:2.0.1"
   dependencies:
@@ -11779,7 +12700,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"https-proxy-agent@npm:^7.0.0, https-proxy-agent@npm:^7.0.1":
+"https-proxy-agent@npm:^7.0.0, https-proxy-agent@npm:^7.0.1, https-proxy-agent@npm:^7.0.5":
   version: 7.0.6
   resolution: "https-proxy-agent@npm:7.0.6"
   dependencies:
@@ -11837,7 +12758,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"iconv-lite@npm:^0.7.0, iconv-lite@npm:^0.7.2":
+"iconv-lite@npm:^0.7.0, iconv-lite@npm:^0.7.2, iconv-lite@npm:~0.7.0":
   version: 0.7.2
   resolution: "iconv-lite@npm:0.7.2"
   dependencies:
@@ -11862,6 +12783,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"ignore-by-default@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "ignore-by-default@npm:2.1.0"
+  checksum: 10c0/3a6040dac25ed9da39dee73bf1634fdd1e15b0eb7cf52a6bdec81c310565782d8811c104ce40acb3d690d61c5fc38a91c78e6baee830a8a2232424dbc6b66981
+  languageName: node
+  linkType: hard
+
 "ignore-walk@npm:^8.0.0":
   version: 8.0.0
   resolution: "ignore-walk@npm:8.0.0"
@@ -11885,7 +12813,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ignore@npm:^7.0.5":
+"ignore@npm:^7.0.3, ignore@npm:^7.0.5":
   version: 7.0.5
   resolution: "ignore@npm:7.0.5"
   checksum: 10c0/ae00db89fe873064a093b8999fe4cc284b13ef2a178636211842cceb650b9c3e390d3339191acb145d81ed5379d2074840cf0c33a20bdbd6f32821f79eb4ad5d
@@ -12070,7 +12998,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ip-address@npm:^10.0.1":
+"ip-address@npm:10.1.0, ip-address@npm:^10.0.1":
   version: 10.1.0
   resolution: "ip-address@npm:10.1.0"
   checksum: 10c0/0103516cfa93f6433b3bd7333fa876eb21263912329bfa47010af5e16934eeeff86f3d2ae700a3744a137839ddfad62b900c7a445607884a49b5d1e32a3d7566
@@ -12091,6 +13019,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"irregular-plurals@npm:^3.3.0":
+  version: 3.5.0
+  resolution: "irregular-plurals@npm:3.5.0"
+  checksum: 10c0/7c033bbe7325e5a6e0a26949cc6863b6ce273403d4cd5b93bd99b33fecb6605b0884097c4259c23ed0c52c2133bf7d1cdcdd7a0630e8c325161fe269b3447918
+  languageName: node
+  linkType: hard
+
 "is-absolute@npm:^1.0.0":
   version: 1.0.0
   resolution: "is-absolute@npm:1.0.0"
@@ -12265,6 +13200,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-fullwidth-code-point@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "is-fullwidth-code-point@npm:4.0.0"
+  checksum: 10c0/df2a717e813567db0f659c306d61f2f804d480752526886954a2a3e2246c7745fd07a52b5fecf2b68caf0a6c79dcdace6166fdf29cc76ed9975cc334f0a018b8
+  languageName: node
+  linkType: hard
+
 "is-fullwidth-code-point@npm:^5.0.0, is-fullwidth-code-point@npm:^5.1.0":
   version: 5.1.0
   resolution: "is-fullwidth-code-point@npm:5.1.0"
@@ -12390,6 +13332,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-plain-object@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "is-plain-object@npm:5.0.0"
+  checksum: 10c0/893e42bad832aae3511c71fd61c0bf61aa3a6d853061c62a307261842727d0d25f761ce9379f7ba7226d6179db2a3157efa918e7fe26360f3bf0842d9f28942c
+  languageName: node
+  linkType: hard
+
 "is-port-reachable@npm:^3.1.0":
   version: 3.1.0
   resolution: "is-port-reachable@npm:3.1.0"
@@ -12397,6 +13346,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-promise@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "is-promise@npm:4.0.0"
+  checksum: 10c0/ebd5c672d73db781ab33ccb155fb9969d6028e37414d609b115cc534654c91ccd061821d5b987eefaa97cf4c62f0b909bb2f04db88306de26e91bfe8ddc01503
+  languageName: node
+  linkType: hard
+
 "is-regex@npm:^1.2.1":
   version: 1.2.1
   resolution: "is-regex@npm:1.2.1"
@@ -12746,6 +13702,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"jackspeak@npm:^3.1.2":
+  version: 3.4.3
+  resolution: "jackspeak@npm:3.4.3"
+  dependencies:
+    "@isaacs/cliui": "npm:^8.0.2"
+    "@pkgjs/parseargs": "npm:^0.11.0"
+  dependenciesMeta:
+    "@pkgjs/parseargs":
+      optional: true
+  checksum: 10c0/6acc10d139eaefdbe04d2f679e6191b3abf073f111edf10b1de5302c97ec93fffeb2fdd8681ed17f16268aa9dd4f8c588ed9d1d3bffbbfa6e8bf897cbb3149b9
+  languageName: node
+  linkType: hard
+
 "jackspeak@npm:^4.1.1":
   version: 4.2.3
   resolution: "jackspeak@npm:4.2.3"
@@ -12842,6 +13811,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"jose@npm:^6.1.3":
+  version: 6.2.1
+  resolution: "jose@npm:6.2.1"
+  checksum: 10c0/456822e00a2ee6b1470fabadd694b237af64b9977aa8a47844aae2841298daefd79bb04ff328cbc3aa3c886761aa72b33bc5c1ad797b31b8368e77a89d09b779
+  languageName: node
+  linkType: hard
+
+"js-string-escape@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "js-string-escape@npm:1.0.1"
+  checksum: 10c0/2c33b9ff1ba6b84681c51ca0997e7d5a1639813c95d5b61cb7ad47e55cc28fa4a0b1935c3d218710d8e6bcee5d0cd8c44755231e3a4e45fc604534d9595a3628
+  languageName: node
+  linkType: hard
+
 "js-tokens@npm:^3.0.0 || ^4.0.0, js-tokens@npm:^4.0.0":
   version: 4.0.0
   resolution: "js-tokens@npm:4.0.0"
@@ -12860,7 +13843,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"js-yaml@npm:^3.10.0, js-yaml@npm:^3.13.1":
+"js-yaml@npm:^3.10.0, js-yaml@npm:^3.13.1, js-yaml@npm:^3.14.1":
   version: 3.14.2
   resolution: "js-yaml@npm:3.14.2"
   dependencies:
@@ -12946,6 +13929,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"json-schema-typed@npm:^8.0.2":
+  version: 8.0.2
+  resolution: "json-schema-typed@npm:8.0.2"
+  checksum: 10c0/89f5e2fb1495483b705c027203c07277ee6bf2665165ad25a9cb55de5af7f72570326d13d32565180781e4083ad5c9688102f222baed7b353c2f39c1e02b0428
+  languageName: node
+  linkType: hard
+
 "json-schema@npm:0.4.0":
   version: 0.4.0
   resolution: "json-schema@npm:0.4.0"
@@ -13447,6 +14437,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"load-json-file@npm:^7.0.1":
+  version: 7.0.1
+  resolution: "load-json-file@npm:7.0.1"
+  checksum: 10c0/7117459608a0b6329c7f78e6e1f541b3162dd901c29dd5af721fec8b270177d2e3d7999c971f344fff04daac368d052732e2c7146014bc84d15e0b636975e19a
+  languageName: node
+  linkType: hard
+
 "loader-utils@npm:^3.2.0":
   version: 3.3.1
   resolution: "loader-utils@npm:3.3.1"
@@ -13652,7 +14649,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lodash@npm:^4.17.20, lodash@npm:^4.17.21, lodash@npm:^4.17.23":
+"lodash@npm:^4.17.15, lodash@npm:^4.17.20, lodash@npm:^4.17.21, lodash@npm:^4.17.23":
   version: 4.17.23
   resolution: "lodash@npm:4.17.23"
   checksum: 10c0/1264a90469f5bb95d4739c43eb6277d15b6d9e186df4ac68c3620443160fc669e2f14c11e7d8b2ccf078b81d06147c01a8ccced9aab9f9f63d50dcf8cace6bf6
@@ -13749,7 +14746,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lru-cache@npm:^10.0.1":
+"lru-cache@npm:^10.0.1, lru-cache@npm:^10.2.0":
   version: 10.4.3
   resolution: "lru-cache@npm:10.4.3"
   checksum: 10c0/ebd04fbca961e6c1d6c0af3799adcc966a1babe798f685bb84e6599266599cd95d94630b10262f5424539bc4640107e8a33aa28585374abf561d30d16f4b39fb
@@ -13924,6 +14921,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"matcher@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "matcher@npm:5.0.0"
+  dependencies:
+    escape-string-regexp: "npm:^5.0.0"
+  checksum: 10c0/eda5471fc9d5b7264d63c81727824adc3585ddb5cfdc5fce5a9b7c86f946ff181610735d330b1c37a84811df872d1290bf4e9401d2be2a414204343701144b18
+  languageName: node
+  linkType: hard
+
 "math-intrinsics@npm:^1.1.0":
   version: 1.1.0
   resolution: "math-intrinsics@npm:1.1.0"
@@ -13931,6 +14937,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"md5-hex@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "md5-hex@npm:3.0.1"
+  dependencies:
+    blueimp-md5: "npm:^2.10.0"
+  checksum: 10c0/ee2b4d8da16b527b3a3fe4d7a96720f43afd07b46a82d49421208b5a126235fb75cfb30b80d4029514772c8844273f940bddfbf4155c787f968f3be4060d01e4
+  languageName: node
+  linkType: hard
+
 "mdast-util-definitions@npm:^5.0.0":
   version: 5.1.2
   resolution: "mdast-util-definitions@npm:5.1.2"
@@ -14299,6 +15314,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"memoize@npm:^10.1.0":
+  version: 10.2.0
+  resolution: "memoize@npm:10.2.0"
+  dependencies:
+    mimic-function: "npm:^5.0.1"
+  checksum: 10c0/8a5891f313e8db82bab4bb9694752aab40c11ce3bf9b8cc32228ebaf87e14e8109a23b37ceef32baadbedc09af2c4dd0d361a93e9e591bb0ed9e23f728e1ce9f
+  languageName: node
+  linkType: hard
+
 "memorystream@npm:^0.3.1":
   version: 0.3.1
   resolution: "memorystream@npm:0.3.1"
@@ -14332,6 +15356,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"merge-descriptors@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "merge-descriptors@npm:2.0.0"
+  checksum: 10c0/95389b7ced3f9b36fbdcf32eb946dc3dd1774c2fdf164609e55b18d03aa499b12bd3aae3a76c1c7185b96279e9803525550d3eb292b5224866060a288f335cb3
+  languageName: node
+  linkType: hard
+
 "merge-stream@npm:^2.0.0":
   version: 2.0.0
   resolution: "merge-stream@npm:2.0.0"
@@ -15044,7 +16075,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mime-types@npm:^3.0.0, mime-types@npm:^3.0.1":
+"mime-types@npm:^3.0.0, mime-types@npm:^3.0.1, mime-types@npm:^3.0.2":
   version: 3.0.2
   resolution: "mime-types@npm:3.0.2"
   dependencies:
@@ -15078,7 +16109,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mimic-function@npm:^5.0.0":
+"mimic-function@npm:^5.0.0, mimic-function@npm:^5.0.1":
   version: 5.0.1
   resolution: "mimic-function@npm:5.0.1"
   checksum: 10c0/f3d9464dd1816ecf6bdf2aec6ba32c0728022039d992f178237d8e289b48764fee4131319e72eedd4f7f094e22ded0af836c3187a7edc4595d28dd74368fd81d
@@ -15169,6 +16200,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"minimatch@npm:^9.0.4":
+  version: 9.0.9
+  resolution: "minimatch@npm:9.0.9"
+  dependencies:
+    brace-expansion: "npm:^2.0.2"
+  checksum: 10c0/0b6a58530dbb00361745aa6c8cffaba4c90f551afe7c734830bd95fd88ebf469dd7355a027824ea1d09e37181cfeb0a797fb17df60c15ac174303ac110eb7e86
+  languageName: node
+  linkType: hard
+
 "minimatch@npm:~3.0.2":
   version: 3.0.8
   resolution: "minimatch@npm:3.0.8"
@@ -15280,7 +16320,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"minipass@npm:^7.0.2, minipass@npm:^7.0.3, minipass@npm:^7.0.4, minipass@npm:^7.1.2, minipass@npm:^7.1.3":
+"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.2, minipass@npm:^7.0.3, minipass@npm:^7.0.4, minipass@npm:^7.1.2, minipass@npm:^7.1.3":
   version: 7.1.3
   resolution: "minipass@npm:7.1.3"
   checksum: 10c0/539da88daca16533211ea5a9ee98dc62ff5742f531f54640dd34429e621955e91cc280a91a776026264b7f9f6735947629f920944e9c1558369e8bf22eb33fbb
@@ -15533,6 +16573,31 @@ __metadata:
   languageName: node
   linkType: hard
 
+"node-fetch@npm:^2.6.7":
+  version: 2.7.0
+  resolution: "node-fetch@npm:2.7.0"
+  dependencies:
+    whatwg-url: "npm:^5.0.0"
+  peerDependencies:
+    encoding: ^0.1.0
+  peerDependenciesMeta:
+    encoding:
+      optional: true
+  checksum: 10c0/b55786b6028208e6fbe594ccccc213cab67a72899c9234eb59dba51062a299ea853210fcf526998eaa2867b0963ad72338824450905679ff0fa304b8c5093ae8
+  languageName: node
+  linkType: hard
+
+"node-gyp-build@npm:^4.2.2":
+  version: 4.8.4
+  resolution: "node-gyp-build@npm:4.8.4"
+  bin:
+    node-gyp-build: bin.js
+    node-gyp-build-optional: optional.js
+    node-gyp-build-test: build-test.js
+  checksum: 10c0/444e189907ece2081fe60e75368784f7782cfddb554b60123743dfb89509df89f1f29c03bbfa16b3a3e0be3f48799a4783f487da6203245fa5bed239ba7407e1
+  languageName: node
+  linkType: hard
+
 "node-gyp@npm:^12.1.0, node-gyp@npm:latest":
   version: 12.2.0
   resolution: "node-gyp@npm:12.2.0"
@@ -15583,6 +16648,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"nofilter@npm:^3.0.2":
+  version: 3.1.0
+  resolution: "nofilter@npm:3.1.0"
+  checksum: 10c0/92459f3864a067b347032263f0b536223cbfc98153913b5dce350cb39c8470bc1813366e41993f22c33cc6400c0f392aa324a4b51e24c22040635c1cdb046499
+  languageName: node
+  linkType: hard
+
 "nopt@npm:^8.0.0":
   version: 8.1.0
   resolution: "nopt@npm:8.1.0"
@@ -15977,7 +17049,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"object-assign@npm:^4.1.1":
+"object-assign@npm:^4, object-assign@npm:^4.1.1":
   version: 4.1.1
   resolution: "object-assign@npm:4.1.1"
   checksum: 10c0/1f4df9945120325d041ccf7b86f31e8bcc14e73d29171e37a7903050e96b81323784ec59f93f102ec635bcf6fa8034ba3ea0a8c7e69fa202b87ae3b6cec5a414
@@ -16343,7 +17415,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"p-map@npm:^7.0.1, p-map@npm:^7.0.2":
+"p-map@npm:^7.0.1, p-map@npm:^7.0.2, p-map@npm:^7.0.3":
   version: 7.0.4
   resolution: "p-map@npm:7.0.4"
   checksum: 10c0/a5030935d3cb2919d7e89454d1ce82141e6f9955413658b8c9403cfe379283770ed3048146b44cde168aa9e8c716505f196d5689db0ae3ce9a71521a2fef3abd
@@ -16406,6 +17478,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"package-config@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "package-config@npm:5.0.0"
+  dependencies:
+    find-up-simple: "npm:^1.0.0"
+    load-json-file: "npm:^7.0.1"
+  checksum: 10c0/f6c48930700b73a41d839bf2898b628d23665827488a4f34aed2d05e4a99d7a70a70ada115c3546765947fbc8accff94c0779da21ea084b25df47cb774531eeb
+  languageName: node
+  linkType: hard
+
 "package-hash@npm:^4.0.0":
   version: 4.0.0
   resolution: "package-hash@npm:4.0.0"
@@ -16685,6 +17767,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"path-scurry@npm:^1.11.1":
+  version: 1.11.1
+  resolution: "path-scurry@npm:1.11.1"
+  dependencies:
+    lru-cache: "npm:^10.2.0"
+    minipass: "npm:^5.0.0 || ^6.0.2 || ^7.0.0"
+  checksum: 10c0/32a13711a2a505616ae1cc1b5076801e453e7aae6ac40ab55b388bb91b9d0547a52f5aaceff710ea400205f18691120d4431e520afbe4266b836fadede15872d
+  languageName: node
+  linkType: hard
+
 "path-scurry@npm:^2.0.0, path-scurry@npm:^2.0.2":
   version: 2.0.2
   resolution: "path-scurry@npm:2.0.2"
@@ -16695,6 +17787,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"path-to-regexp@npm:^8.0.0":
+  version: 8.3.0
+  resolution: "path-to-regexp@npm:8.3.0"
+  checksum: 10c0/ee1544a73a3f294a97a4c663b0ce71bbf1621d732d80c9c9ed201b3e911a86cb628ebad691b9d40f40a3742fe22011e5a059d8eed2cf63ec2cb94f6fb4efe67c
+  languageName: node
+  linkType: hard
+
 "path-to-regexp@npm:~0.1.12":
   version: 0.1.12
   resolution: "path-to-regexp@npm:0.1.12"
@@ -16729,6 +17828,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"path-type@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "path-type@npm:6.0.0"
+  checksum: 10c0/55baa8b1187d6dc683d5a9cfcc866168d6adff58e5db91126795376d818eee46391e00b2a4d53e44d844c7524a7d96aa68cc68f4f3e500d3d069a39e6535481c
+  languageName: node
+  linkType: hard
+
 "pathval@npm:^1.1.1":
   version: 1.1.1
   resolution: "pathval@npm:1.1.1"
@@ -16831,6 +17937,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"pkce-challenge@npm:^5.0.0":
+  version: 5.0.1
+  resolution: "pkce-challenge@npm:5.0.1"
+  checksum: 10c0/207f4cb976682f27e8324eb49cf71937c98fbb8341a0b8f6142bc6f664825b30e049a54a21b5c034e823ee3c3d412f10d74bd21de78e17452a6a496c2991f57c
+  languageName: node
+  linkType: hard
+
 "pkg-dir@npm:4.2.0, pkg-dir@npm:^4.1.0, pkg-dir@npm:^4.2.0":
   version: 4.2.0
   resolution: "pkg-dir@npm:4.2.0"
@@ -16864,6 +17977,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"plur@npm:^5.1.0":
+  version: 5.1.0
+  resolution: "plur@npm:5.1.0"
+  dependencies:
+    irregular-plurals: "npm:^3.3.0"
+  checksum: 10c0/26bb622b8545fcfd47bbf56fbcca66c08693708a232e403fa3589e00003c56c14231ac57c7588ca5db83ef4be1f61383402c4ea954000768f779f8aef6eb6da8
+  languageName: node
+  linkType: hard
+
 "possible-typed-array-names@npm:^1.0.0":
   version: 1.1.0
   resolution: "possible-typed-array-names@npm:1.1.0"
@@ -17641,7 +18763,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"proxy-addr@npm:~2.0.7":
+"proxy-addr@npm:^2.0.7, proxy-addr@npm:~2.0.7":
   version: 2.0.7
   resolution: "proxy-addr@npm:2.0.7"
   dependencies:
@@ -17729,6 +18851,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"qs@npm:^6.14.0, qs@npm:^6.14.1":
+  version: 6.15.0
+  resolution: "qs@npm:6.15.0"
+  dependencies:
+    side-channel: "npm:^1.1.0"
+  checksum: 10c0/ff341078a78a991d8a48b4524d52949211447b4b1ad907f489cac0770cbc346a28e47304455c0320e5fb000f8762d64b03331e3b71865f663bf351bcba8cdb4b
+  languageName: node
+  linkType: hard
+
 "qs@npm:~6.14.0, qs@npm:~6.14.1":
   version: 6.14.2
   resolution: "qs@npm:6.14.2"
@@ -17775,13 +18906,25 @@ __metadata:
   languageName: node
   linkType: hard
 
-"range-parser@npm:~1.2.1":
+"range-parser@npm:^1.2.1, range-parser@npm:~1.2.1":
   version: 1.2.1
   resolution: "range-parser@npm:1.2.1"
   checksum: 10c0/96c032ac2475c8027b7a4e9fe22dc0dfe0f6d90b85e496e0f016fbdb99d6d066de0112e680805075bd989905e2123b3b3d002765149294dce0c1f7f01fcc2ea0
   languageName: node
   linkType: hard
 
+"raw-body@npm:^3.0.0, raw-body@npm:^3.0.1":
+  version: 3.0.2
+  resolution: "raw-body@npm:3.0.2"
+  dependencies:
+    bytes: "npm:~3.1.2"
+    http-errors: "npm:~2.0.1"
+    iconv-lite: "npm:~0.7.0"
+    unpipe: "npm:~1.0.0"
+  checksum: 10c0/d266678d08e1e7abea62c0ce5864344e980fa81c64f6b481e9842c5beaed2cdcf975f658a3ccd67ad35fc919c1f6664ccc106067801850286a6cbe101de89f29
+  languageName: node
+  linkType: hard
+
 "raw-body@npm:~2.5.3":
   version: 2.5.3
   resolution: "raw-body@npm:2.5.3"
@@ -17803,7 +18946,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-docgen-typescript@npm:^2.2.2":
+"react-docgen-typescript@npm:^2.2.2, react-docgen-typescript@npm:^2.4.0":
   version: 2.4.0
   resolution: "react-docgen-typescript@npm:2.4.0"
   peerDependencies:
@@ -18671,6 +19814,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"router@npm:^2.2.0":
+  version: 2.2.0
+  resolution: "router@npm:2.2.0"
+  dependencies:
+    debug: "npm:^4.4.0"
+    depd: "npm:^2.0.0"
+    is-promise: "npm:^4.0.0"
+    parseurl: "npm:^1.3.3"
+    path-to-regexp: "npm:^8.0.0"
+  checksum: 10c0/3279de7450c8eae2f6e095e9edacbdeec0abb5cb7249c6e719faa0db2dba43574b4fff5892d9220631c9abaff52dd3cad648cfea2aaace845e1a071915ac8867
+  languageName: node
+  linkType: hard
+
 "rs-module-lexer@npm:^2.5.1":
   version: 2.8.0
   resolution: "rs-module-lexer@npm:2.8.0"
@@ -18860,6 +20016,25 @@ __metadata:
   languageName: node
   linkType: hard
 
+"send@npm:^1.1.0, send@npm:^1.2.0":
+  version: 1.2.1
+  resolution: "send@npm:1.2.1"
+  dependencies:
+    debug: "npm:^4.4.3"
+    encodeurl: "npm:^2.0.0"
+    escape-html: "npm:^1.0.3"
+    etag: "npm:^1.8.1"
+    fresh: "npm:^2.0.0"
+    http-errors: "npm:^2.0.1"
+    mime-types: "npm:^3.0.2"
+    ms: "npm:^2.1.3"
+    on-finished: "npm:^2.4.1"
+    range-parser: "npm:^1.2.1"
+    statuses: "npm:^2.0.2"
+  checksum: 10c0/fbbbbdc902a913d65605274be23f3d604065cfc3ee3d78bf9fc8af1dc9fc82667c50d3d657f5e601ac657bac9b396b50ee97bd29cd55436320cf1cddebdcec72
+  languageName: node
+  linkType: hard
+
 "send@npm:~0.19.0, send@npm:~0.19.1":
   version: 0.19.2
   resolution: "send@npm:0.19.2"
@@ -18881,6 +20056,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"serialize-error@npm:^7.0.1":
+  version: 7.0.1
+  resolution: "serialize-error@npm:7.0.1"
+  dependencies:
+    type-fest: "npm:^0.13.1"
+  checksum: 10c0/7982937d578cd901276c8ab3e2c6ed8a4c174137730f1fb0402d005af209a0e84d04acc874e317c936724c7b5b26c7a96ff7e4b8d11a469f4924a4b0ea814c05
+  languageName: node
+  linkType: hard
+
 "serialize-error@npm:^8.0.0":
   version: 8.1.0
   resolution: "serialize-error@npm:8.1.0"
@@ -18899,6 +20083,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"serve-static@npm:^2.2.0":
+  version: 2.2.1
+  resolution: "serve-static@npm:2.2.1"
+  dependencies:
+    encodeurl: "npm:^2.0.0"
+    escape-html: "npm:^1.0.3"
+    parseurl: "npm:^1.3.3"
+    send: "npm:^1.2.0"
+  checksum: 10c0/37986096e8572e2dfaad35a3925fa8da0c0969f8814fd7788e84d4d388bc068cf0c06d1658509788e55bed942a6b6d040a8a267fa92bb9ffb1179f8bacde5fd7
+  languageName: node
+  linkType: hard
+
 "serve-static@npm:~1.16.2":
   version: 1.16.3
   resolution: "serve-static@npm:1.16.3"
@@ -19089,7 +20285,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"slash@npm:^5.0.0":
+"slash@npm:^5.0.0, slash@npm:^5.1.0":
   version: 5.1.0
   resolution: "slash@npm:5.1.0"
   checksum: 10c0/eb48b815caf0bdc390d0519d41b9e0556a14380f6799c72ba35caf03544d501d18befdeeef074bc9c052acf69654bc9e0d79d7f1de0866284137a40805299eb3
@@ -19118,6 +20314,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"slice-ansi@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "slice-ansi@npm:5.0.0"
+  dependencies:
+    ansi-styles: "npm:^6.0.0"
+    is-fullwidth-code-point: "npm:^4.0.0"
+  checksum: 10c0/2d4d40b2a9d5cf4e8caae3f698fe24ae31a4d778701724f578e984dcb485ec8c49f0c04dab59c401821e80fcdfe89cace9c66693b0244e40ec485d72e543914f
+  languageName: node
+  linkType: hard
+
 "slice-ansi@npm:^7.1.0":
   version: 7.1.2
   resolution: "slice-ansi@npm:7.1.2"
@@ -19330,7 +20536,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"stack-utils@npm:^2.0.3":
+"stack-utils@npm:^2.0.3, stack-utils@npm:^2.0.6":
   version: 2.0.6
   resolution: "stack-utils@npm:2.0.6"
   dependencies:
@@ -19346,7 +20552,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"statuses@npm:^2.0.1, statuses@npm:~2.0.1, statuses@npm:~2.0.2":
+"statuses@npm:^2.0.1, statuses@npm:^2.0.2, statuses@npm:~2.0.1, statuses@npm:~2.0.2":
   version: 2.0.2
   resolution: "statuses@npm:2.0.2"
   checksum: 10c0/a9947d98ad60d01f6b26727570f3bcceb6c8fa789da64fe6889908fe2e294d57503b14bf2b5af7605c2d36647259e856635cd4c49eab41667658ec9d0080ec3f
@@ -19411,7 +20617,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"string-width@npm:^1.0.2 || 2 || 3 || 4, string-width@npm:^4.1.0, string-width@npm:^4.2.0, string-width@npm:^4.2.3":
+"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^1.0.2 || 2 || 3 || 4, string-width@npm:^4.1.0, string-width@npm:^4.2.0, string-width@npm:^4.2.3":
   version: 4.2.3
   resolution: "string-width@npm:4.2.3"
   dependencies:
@@ -19422,7 +20628,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"string-width@npm:^5.0.0":
+"string-width@npm:^5.0.0, string-width@npm:^5.0.1, string-width@npm:^5.1.2":
   version: 5.1.2
   resolution: "string-width@npm:5.1.2"
   dependencies:
@@ -19551,6 +20757,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"strip-ansi-cjs@npm:strip-ansi@^6.0.1, strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1":
+  version: 6.0.1
+  resolution: "strip-ansi@npm:6.0.1"
+  dependencies:
+    ansi-regex: "npm:^5.0.1"
+  checksum: 10c0/1ae5f212a126fe5b167707f716942490e3933085a5ff6c008ab97ab2f272c8025d3aa218b7bd6ab25729ca20cc81cddb252102f8751e13482a5199e873680952
+  languageName: node
+  linkType: hard
+
 "strip-ansi@npm:^3.0.0":
   version: 3.0.1
   resolution: "strip-ansi@npm:3.0.1"
@@ -19560,15 +20775,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1":
-  version: 6.0.1
-  resolution: "strip-ansi@npm:6.0.1"
-  dependencies:
-    ansi-regex: "npm:^5.0.1"
-  checksum: 10c0/1ae5f212a126fe5b167707f716942490e3933085a5ff6c008ab97ab2f272c8025d3aa218b7bd6ab25729ca20cc81cddb252102f8751e13482a5199e873680952
-  languageName: node
-  linkType: hard
-
 "strip-ansi@npm:^7.0.1, strip-ansi@npm:^7.1.0, strip-ansi@npm:^7.1.2":
   version: 7.2.0
   resolution: "strip-ansi@npm:7.2.0"
@@ -19664,6 +20870,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"supertap@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "supertap@npm:3.0.1"
+  dependencies:
+    indent-string: "npm:^5.0.0"
+    js-yaml: "npm:^3.14.1"
+    serialize-error: "npm:^7.0.1"
+    strip-ansi: "npm:^7.0.1"
+  checksum: 10c0/8164674f2e280cab875f0fef5bb36c15553c13e29697ff92f4e0d6bc62149f0303a89eee47535413ed145ea72e14a24d065bab233059d48a499ec5ebb4566b0f
+  languageName: node
+  linkType: hard
+
 "supports-color@npm:8.1.1, supports-color@npm:^8.1.1":
   version: 8.1.1
   resolution: "supports-color@npm:8.1.1"
@@ -19786,7 +21004,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tar@npm:7.5.11":
+"tar@npm:7.5.11, tar@npm:^7.4.0":
   version: 7.5.11
   resolution: "tar@npm:7.5.11"
   dependencies:
@@ -19822,6 +21040,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"temp-dir@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "temp-dir@npm:3.0.0"
+  checksum: 10c0/a86978a400984cd5f315b77ebf3fe53bb58c61f192278cafcb1f3fb32d584a21dc8e08b93171d7874b7cc972234d3455c467306cc1bfc4524b622e5ad3bfd671
+  languageName: node
+  linkType: hard
+
 "test-exclude@npm:^6.0.0":
   version: 6.0.0
   resolution: "test-exclude@npm:6.0.0"
@@ -19889,6 +21114,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"time-zone@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "time-zone@npm:1.0.0"
+  checksum: 10c0/d00ebd885039109011b6e2423ebbf225160927333c2ade6d833e9cc4676db20759f1f3855fafde00d1bd668c243a6aa68938ce71fe58aab0d514e820d59c1d81
+  languageName: node
+  linkType: hard
+
 "tiny-invariant@npm:^1.3.1, tiny-invariant@npm:^1.3.3":
   version: 1.3.3
   resolution: "tiny-invariant@npm:1.3.3"
@@ -20155,6 +21387,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tsx@npm:^4.20.6":
+  version: 4.21.0
+  resolution: "tsx@npm:4.21.0"
+  dependencies:
+    esbuild: "npm:~0.27.0"
+    fsevents: "npm:~2.3.3"
+    get-tsconfig: "npm:^4.7.5"
+  dependenciesMeta:
+    fsevents:
+      optional: true
+  bin:
+    tsx: dist/cli.mjs
+  checksum: 10c0/f5072923cd8459a1f9a26df87823a2ab5754641739d69df2a20b415f61814322b751fa6be85db7c6ec73cf68ba8fac2fd1cfc76bdb0aa86ded984d84d5d2126b
+  languageName: node
+  linkType: hard
+
 "tuf-js@npm:^4.1.0":
   version: 4.1.0
   resolution: "tuf-js@npm:4.1.0"
@@ -20198,6 +21446,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"type-fest@npm:^0.13.1":
+  version: 0.13.1
+  resolution: "type-fest@npm:0.13.1"
+  checksum: 10c0/0c0fa07ae53d4e776cf4dac30d25ad799443e9eef9226f9fddbb69242db86b08584084a99885cfa5a9dfe4c063ebdc9aa7b69da348e735baede8d43f1aeae93b
+  languageName: node
+  linkType: hard
+
 "type-fest@npm:^0.18.0":
   version: 0.18.1
   resolution: "type-fest@npm:0.18.1"
@@ -20539,6 +21794,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"undici-types@npm:~6.21.0":
+  version: 6.21.0
+  resolution: "undici-types@npm:6.21.0"
+  checksum: 10c0/c01ed51829b10aa72fc3ce64b747f8e74ae9b60eafa19a7b46ef624403508a54c526ffab06a14a26b3120d055e1104d7abe7c9017e83ced038ea5cf52f8d5e04
+  languageName: node
+  linkType: hard
+
 "undici-types@npm:~7.16.0":
   version: 7.16.0
   resolution: "undici-types@npm:7.16.0"
@@ -20986,7 +22248,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"vary@npm:^1.1.2, vary@npm:~1.1.2":
+"vary@npm:^1, vary@npm:^1.1.2, vary@npm:~1.1.2":
   version: 1.1.2
   resolution: "vary@npm:1.1.2"
   checksum: 10c0/f15d588d79f3675135ba783c91a4083dcd290a2a5be9fcb6514220a1634e23df116847b1cc51f66bfb0644cf9353b2abb7815ae499bab06e46dd33c1a6bf1f4f
@@ -21437,6 +22699,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"well-known-symbols@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "well-known-symbols@npm:2.0.0"
+  checksum: 10c0/cb6c12e98877e8952ec28d13ae6f4fdb54ae1cb49b16a728720276dadd76c930e6cb0e174af3a4620054dd2752546f842540122920c6e31410208abd4958ee6b
+  languageName: node
+  linkType: hard
+
 "whatwg-url@npm:^5.0.0":
   version: 5.0.0
   resolution: "whatwg-url@npm:5.0.0"
@@ -21589,6 +22858,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0, wrap-ansi@npm:^7.0.0":
+  version: 7.0.0
+  resolution: "wrap-ansi@npm:7.0.0"
+  dependencies:
+    ansi-styles: "npm:^4.0.0"
+    string-width: "npm:^4.1.0"
+    strip-ansi: "npm:^6.0.0"
+  checksum: 10c0/d15fc12c11e4cbc4044a552129ebc75ee3f57aa9c1958373a4db0292d72282f54373b536103987a4a7594db1ef6a4f10acf92978f79b98c49306a4b58c77d4da
+  languageName: node
+  linkType: hard
+
 "wrap-ansi@npm:^6.2.0":
   version: 6.2.0
   resolution: "wrap-ansi@npm:6.2.0"
@@ -21600,14 +22880,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"wrap-ansi@npm:^7.0.0":
-  version: 7.0.0
-  resolution: "wrap-ansi@npm:7.0.0"
+"wrap-ansi@npm:^8.1.0":
+  version: 8.1.0
+  resolution: "wrap-ansi@npm:8.1.0"
   dependencies:
-    ansi-styles: "npm:^4.0.0"
-    string-width: "npm:^4.1.0"
-    strip-ansi: "npm:^6.0.0"
-  checksum: 10c0/d15fc12c11e4cbc4044a552129ebc75ee3f57aa9c1958373a4db0292d72282f54373b536103987a4a7594db1ef6a4f10acf92978f79b98c49306a4b58c77d4da
+    ansi-styles: "npm:^6.1.0"
+    string-width: "npm:^5.0.1"
+    strip-ansi: "npm:^7.0.1"
+  checksum: 10c0/138ff58a41d2f877eae87e3282c0630fc2789012fc1af4d6bd626eeb9a2f9a65ca92005e6e69a75c7b85a68479fe7443c7dbe1eb8fbaa681a4491364b7c55c60
   languageName: node
   linkType: hard
 
@@ -21816,7 +23096,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yargs@npm:17.7.2, yargs@npm:^17.0.0, yargs@npm:^17.5.1, yargs@npm:^17.6.2":
+"yargs@npm:17.7.2, yargs@npm:^17.0.0, yargs@npm:^17.5.1, yargs@npm:^17.6.2, yargs@npm:^17.7.2":
   version: 17.7.2
   resolution: "yargs@npm:17.7.2"
   dependencies:
@@ -21928,6 +23208,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"zod-to-json-schema@npm:^3.25.1":
+  version: 3.25.1
+  resolution: "zod-to-json-schema@npm:3.25.1"
+  peerDependencies:
+    zod: ^3.25 || ^4
+  checksum: 10c0/711b30e34d1f1211f1afe64bf457f0d799234199dc005cca720b236ea808804c03164039c232f5df33c46f462023874015a8a0b3aab1585eca14124c324db7e2
+  languageName: node
+  linkType: hard
+
 "zod-validation-error@npm:^3.5.0 || ^4.0.0":
   version: 4.0.2
   resolution: "zod-validation-error@npm:4.0.2"
@@ -21937,13 +23226,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"zod@npm:^3.25.0 || ^4.0.0":
+"zod@npm:^3.25 || ^4.0, zod@npm:^3.25.0 || ^4.0.0":
   version: 4.3.6
   resolution: "zod@npm:4.3.6"
   checksum: 10c0/860d25a81ab41d33aa25f8d0d07b091a04acb426e605f396227a796e9e800c44723ed96d0f53a512b57be3d1520f45bf69c0cb3b378a232a00787a2609625307
   languageName: node
   linkType: hard
 
+"zod@npm:^3.25.76":
+  version: 3.25.76
+  resolution: "zod@npm:3.25.76"
+  checksum: 10c0/5718ec35e3c40b600316c5b4c5e4976f7fee68151bc8f8d90ec18a469be9571f072e1bbaace10f1e85cf8892ea12d90821b200e980ab46916a6166a4260a983c
+  languageName: node
+  linkType: hard
+
 "zwitch@npm:^2.0.0, zwitch@npm:^2.0.4":
   version: 2.0.4
   resolution: "zwitch@npm:2.0.4"

From 9473e774c89cd2529c7159ab7796db01559d0560 Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Fri, 27 Mar 2026 14:15:24 +0100
Subject: [PATCH 02/16] refactor, improve scripts, add root script

---
 package.json                                  |   3 +-
 packages/mcp-server/package.json              |  10 +-
 .../{bundle_docs.ts => bundle-docs.ts}        | 103 +++++++++---------
 ...s.ts => extract-component-descriptions.ts} |  32 ++----
 ...eam_skills.ts => fetch-upstream-skills.ts} |  16 ++-
 packages/mcp-server/scripts/post-build.ts     |  39 +++++++
 packages/mcp-server/scripts/utils/cem.ts      |   4 +-
 packages/mcp-server/scripts/utils/docgen.ts   |   4 +-
 .../get_component_api/component-apis.json     |   2 +-
 .../tools/list_components/descriptions.json   |   2 +-
 10 files changed, 124 insertions(+), 91 deletions(-)
 rename packages/mcp-server/scripts/{bundle_docs.ts => bundle-docs.ts} (68%)
 rename packages/mcp-server/scripts/{extract_component_descriptions.ts => extract-component-descriptions.ts} (88%)
 rename packages/mcp-server/scripts/{fetch_upstream_skills.ts => fetch-upstream-skills.ts} (78%)
 create mode 100644 packages/mcp-server/scripts/post-build.ts

diff --git a/package.json b/package.json
index 8fa680545c0..a35d501b13f 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,8 @@
     "create-cypress-commands-docs": "documentation build ./packages/cypress-commands/src/commands.ts -f json -o ./packages/cypress-commands/api-commands.json && documentation build ./packages/cypress-commands/src/queries.ts -f json -o ./packages/cypress-commands/api-queries.json",
     "sb:prepare-cem": "node packages/cli/dist/bin/index.js resolve-cem --packageName @ui5/webcomponents --out ./.storybook/custom-element-manifests/main.json && node packages/cli/dist/bin/index.js resolve-cem --packageName @ui5/webcomponents-fiori --out ./.storybook/custom-element-manifests/fiori.json && node packages/cli/dist/bin/index.js resolve-cem --packageName @ui5/webcomponents-ai --out ./.storybook/custom-element-manifests/ai.json",
     "create-theming-parameters": "node scripts/generate-theming-parameters.js",
-    "create-exports": "node --experimental-strip-types scripts/create-export-paths.ts"
+    "create-exports": "node --experimental-strip-types scripts/create-export-paths.ts",
+    "build:mcp": "yarn workspace @ui5/webcomponents-react-mcp update"
   },
   "dependencies": {
     "@stackblitz/sdk": "1.11.0",
diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index 34bb83986a5..459c447cd71 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -28,13 +28,13 @@
     "directory": "packages/mcp-server"
   },
   "scripts": {
-    "extract:descriptions": "tsx scripts/extract_component_descriptions.ts",
-    "bundle:docs": "tsx scripts/bundle_docs.ts",
-    "build": "tsc --build tsconfig.build.json && cp src/tools/list_components/descriptions.json dist/tools/list_components/descriptions.json && cp src/tools/get_component_api/component-apis.json dist/tools/get_component_api/component-apis.json && cp src/tools/get_documentation/documentation_sections.json dist/tools/get_documentation/documentation_sections.json && node -e \"require('fs').chmodSync('dist/index.js', '755')\"",
-    "fetch:skills": "tsx scripts/fetch_upstream_skills.ts",
+    "extract:descriptions": "tsx scripts/extract-component-descriptions.ts",
+    "bundle:docs": "tsx scripts/bundle-docs.ts",
+    "build": "tsc --build tsconfig.build.json && tsx scripts/post-build.ts",
+    "fetch:skills": "tsx scripts/fetch-upstream-skills.ts",
     "update": "npm run fetch:skills && npm run extract:descriptions && npm run bundle:docs && npm run build",
     "clean": "rimraf dist tsconfig.tsbuildinfo tsconfig.build.tsbuildinfo",
-    "dev": "npm run build && ./dist/index.js",
+    "dev": "npm run build && node dist/index.js",
     "inspector": "npx @modelcontextprotocol/inspector node ./dist/index.js",
     "type-check": "tsc --noEmit",
     "test": "npm run build && ava",
diff --git a/packages/mcp-server/scripts/bundle_docs.ts b/packages/mcp-server/scripts/bundle-docs.ts
similarity index 68%
rename from packages/mcp-server/scripts/bundle_docs.ts
rename to packages/mcp-server/scripts/bundle-docs.ts
index 030bddd7874..a28e951d6ca 100644
--- a/packages/mcp-server/scripts/bundle_docs.ts
+++ b/packages/mcp-server/scripts/bundle-docs.ts
@@ -1,11 +1,9 @@
-#!/usr/bin/env tsx
-
 /**
  * Bundle documentation files from the monorepo into the MCP server package.
  * Copies MDX/MD/TS files referenced in documentation_sections.json to docs/.
  *
- * For entries with a companion `data_source` (JSON), generates LLM-friendly
- * markdown instead of copying raw MDX (which may contain JSX components).
+ * For entries with a `dataSource` (JSON), generates LLM-friendly markdown
+ * instead of copying raw MDX (which may contain JSX components).
  *
  * Usage:
  *   npm run bundle:docs
@@ -17,9 +15,9 @@
 
 import type { DocumentationData } from '../src/types/index.js';
 
-import { readFileSync, writeFileSync, mkdirSync, cpSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { readFileSync, writeFileSync, mkdirSync, cpSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -104,67 +102,72 @@ function generateTemplateMarkdown(dataSourcePath: string): string {
   return md;
 }
 
-function main() {
-  console.log('Bundling documentation files...\n');
-
-  mkdirSync(DOCS_DIR, { recursive: true });
-
-  const docsData: DocumentationData = JSON.parse(readFileSync(SECTIONS_PATH, 'utf-8'));
+interface ProcessResult {
+  copied: number;
+  generated: number;
+  skipped: number;
+}
 
-  let copied = 0;
-  let generated = 0;
-  let skipped = 0;
-
-  function processEntry(entry: { sourcePath?: string; dataSource?: string; localPath?: string }) {
-    // If a dataSource is provided, generate LLM-friendly markdown from it
-    if (entry.dataSource) {
-      const localFilename = toLocalFilename(entry.dataSource).replace(/\.json$/, '.md');
-      const destPath = join(DOCS_DIR, localFilename);
-      const content = generateTemplateMarkdown(entry.dataSource);
-      if (content) {
-        writeFileSync(destPath, content);
-        entry.localPath = localFilename;
-        generated++;
-        console.log(`  ${entry.dataSource} -> docs/${localFilename} (generated)`);
-      }
-      return;
+function processEntry(
+  entry: { sourcePath?: string; dataSource?: string; localPath?: string },
+  result: ProcessResult,
+): void {
+  if (entry.dataSource) {
+    const localFilename = toLocalFilename(entry.dataSource).replace(/\.json$/, '.md');
+    const destPath = join(DOCS_DIR, localFilename);
+    const content = generateTemplateMarkdown(entry.dataSource);
+    if (content) {
+      writeFileSync(destPath, content);
+      entry.localPath = localFilename;
+      result.generated++;
+      console.log(`  ${entry.dataSource} -> docs/${localFilename} (generated)`);
     }
+    return;
+  }
 
-    if (!entry.sourcePath) return;
+  if (!entry.sourcePath) return;
 
-    const sourcePath = join(MONOREPO_ROOT, entry.sourcePath);
-    const localFilename = toLocalFilename(entry.sourcePath);
-    const destPath = join(DOCS_DIR, localFilename);
+  const sourcePath = join(MONOREPO_ROOT, entry.sourcePath);
+  const localFilename = toLocalFilename(entry.sourcePath);
+  const destPath = join(DOCS_DIR, localFilename);
 
-    try {
-      cpSync(sourcePath, destPath);
-      entry.localPath = localFilename;
-      copied++;
-      console.log(`  ${entry.sourcePath} -> docs/${localFilename}`);
-    } catch (error) {
-      console.warn(`  Failed to copy ${entry.sourcePath}: ${(error as Error).message}`);
-      skipped++;
-    }
+  try {
+    cpSync(sourcePath, destPath);
+    entry.localPath = localFilename;
+    result.copied++;
+    console.log(`  ${entry.sourcePath} -> docs/${localFilename}`);
+  } catch (error) {
+    console.warn(`  Failed to copy ${entry.sourcePath}: ${(error as Error).message}`);
+    result.skipped++;
   }
+}
+
+function main() {
+  console.log('Bundling documentation files...\n');
+
+  mkdirSync(DOCS_DIR, { recursive: true });
+
+  const docsData: DocumentationData = JSON.parse(readFileSync(SECTIONS_PATH, 'utf-8'));
+  const result: ProcessResult = { copied: 0, generated: 0, skipped: 0 };
 
   for (const section of docsData.sections) {
-    processEntry(section);
+    processEntry(section, result);
 
     if (section.subsections) {
       for (const subsection of section.subsections) {
-        processEntry(subsection);
+        processEntry(subsection, result);
       }
     }
   }
 
   writeFileSync(SECTIONS_PATH, JSON.stringify(docsData, null, 2) + '\n');
 
-  console.log(`\nBundled ${copied} documentation files to docs/`);
-  if (generated > 0) {
-    console.log(`Generated ${generated} files from data sources`);
+  console.log(`\nBundled ${result.copied} documentation files to docs/`);
+  if (result.generated > 0) {
+    console.log(`Generated ${result.generated} files from data sources`);
   }
-  if (skipped > 0) {
-    console.log(`Skipped ${skipped} files`);
+  if (result.skipped > 0) {
+    console.log(`Skipped ${result.skipped} files`);
   }
   console.log(`Updated ${SECTIONS_PATH}`);
 }
diff --git a/packages/mcp-server/scripts/extract_component_descriptions.ts b/packages/mcp-server/scripts/extract-component-descriptions.ts
similarity index 88%
rename from packages/mcp-server/scripts/extract_component_descriptions.ts
rename to packages/mcp-server/scripts/extract-component-descriptions.ts
index af6ebcf8613..b1aed5c0640 100644
--- a/packages/mcp-server/scripts/extract_component_descriptions.ts
+++ b/packages/mcp-server/scripts/extract-component-descriptions.ts
@@ -1,5 +1,3 @@
-#!/usr/bin/env tsx
-
 /**
  * Extract component descriptions and API data from the monorepo.
  * Reads component source files, parses JSDoc/props via react-docgen-typescript,
@@ -13,11 +11,11 @@
  *   npm run extract:descriptions
  */
 
-import { readFileSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { glob } from 'glob';
-import type { DescriptionsStore, ApiDataStore, ComponentDescription, ComponentApiData } from '../src/types/index.js';
+import type { DescriptionsStore, ApiDataStore } from '../src/types/index.js';
 import {
   REACT_COMPONENT_CATEGORIES,
   WEB_COMPONENT_CATEGORIES,
@@ -40,11 +38,15 @@ async function main() {
   const componentApis: ApiDataStore = { components: {}, webComponents: {}, charts: {}, ai: {} };
   const missingComponents: string[] = [];
 
-  // --- React components ---
-  const componentFiles = (
-    await glob('packages/main/src/components/*/index.{ts,tsx}', { cwd: UI5_WCR_PATH, absolute: true })
-  ).sort();
+  // Glob all component directories in parallel
+  const [componentFiles, wcFiles, chartFiles, aiFiles] = await Promise.all([
+    glob('packages/main/src/components/*/index.{ts,tsx}', { cwd: UI5_WCR_PATH, absolute: true }).then((f) => f.sort()),
+    glob('packages/main/src/webComponents/*/index.tsx', { cwd: UI5_WCR_PATH, absolute: true }).then((f) => f.sort()),
+    glob('packages/charts/src/components/*/index.tsx', { cwd: UI5_WCR_PATH, absolute: true }).then((f) => f.sort()),
+    glob('packages/ai/src/components/*/index.tsx', { cwd: UI5_WCR_PATH, absolute: true }).then((f) => f.sort()),
+  ]);
 
+  // --- React components ---
   console.log(`Found ${componentFiles.length} React components`);
   for (const file of componentFiles) {
     const name = file.split('/').slice(-2, -1)[0];
@@ -65,10 +67,6 @@ async function main() {
   console.log('Loading custom-elements manifests...');
   const { lookup: cemLookup, wcDescriptions, aiDescriptions } = loadCemData(UI5_WCR_PATH);
 
-  const wcFiles = (
-    await glob('packages/main/src/webComponents/*/index.tsx', { cwd: UI5_WCR_PATH, absolute: true })
-  ).sort();
-
   console.log(`Found ${wcFiles.length} Web Components`);
   for (const file of wcFiles) {
     const name = file.split('/').slice(-2, -1)[0];
@@ -88,10 +86,6 @@ async function main() {
   }
 
   // --- Charts ---
-  const chartFiles = (
-    await glob('packages/charts/src/components/*/index.tsx', { cwd: UI5_WCR_PATH, absolute: true })
-  ).sort();
-
   console.log(`Found ${chartFiles.length} Chart components`);
   for (const file of chartFiles) {
     const name = file.split('/').slice(-2, -1)[0];
@@ -109,8 +103,6 @@ async function main() {
   }
 
   // --- AI components ---
-  const aiFiles = (await glob('packages/ai/src/components/*/index.tsx', { cwd: UI5_WCR_PATH, absolute: true })).sort();
-
   console.log(`Found ${aiFiles.length} AI components`);
   for (const file of aiFiles) {
     const name = file.split('/').slice(-2, -1)[0];
diff --git a/packages/mcp-server/scripts/fetch_upstream_skills.ts b/packages/mcp-server/scripts/fetch-upstream-skills.ts
similarity index 78%
rename from packages/mcp-server/scripts/fetch_upstream_skills.ts
rename to packages/mcp-server/scripts/fetch-upstream-skills.ts
index 7af01edc318..be91571a508 100644
--- a/packages/mcp-server/scripts/fetch_upstream_skills.ts
+++ b/packages/mcp-server/scripts/fetch-upstream-skills.ts
@@ -1,5 +1,3 @@
-#!/usr/bin/env tsx
-
 /**
  * Fetch upstream skill documents from the UI5 Web Components repo.
  * Strips YAML frontmatter and adds a header note for React context.
@@ -11,9 +9,9 @@
  *   npm run fetch:skills
  */
 
-import { writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -27,7 +25,7 @@ interface UpstreamSkill {
 
 const SKILLS: UpstreamSkill[] = [
   {
-    url: 'https://raw.githubusercontent.com/SAP/ui5-webcomponents/main/skills/accessibility/SKILL.md',
+    url: 'https://raw.githubusercontent.com/UI5/webcomponents/main/skills/accessibility/SKILL.md',
     outputFile: 'upstream--accessibility.mdx',
   },
 ];
@@ -38,7 +36,7 @@ function stripFrontmatter(content: string): string {
   return match ? content.slice(match[0].length) : content;
 }
 
-const HEADER = `> This document is adapted from the [UI5 Web Components Accessibility Skill](https://github.com/SAP/ui5-webcomponents/blob/main/skills/accessibility/SKILL.md).
+const HEADER = `> This document is adapted from the [UI5 Web Components Accessibility Skill](https://github.com/UI5/webcomponents/blob/main/skills/accessibility/SKILL.md).
 > Code examples use HTML web component syntax (\`<ui5-button>\`, \`accessible-name\`).
 > Use \`get_component_api\` to look up the corresponding React component names and camelCase props.
 
@@ -49,7 +47,7 @@ async function fetchAndAdapt(skill: UpstreamSkill): Promise<void> {
 
   const response = await fetch(skill.url);
   if (!response.ok) {
-    throw new Error(`ERROR: Failed to fetch upstream skill from ${skill.url}. HTTP status: ${response.status}`);
+    throw new Error(`Failed to fetch upstream skill from ${skill.url}. HTTP status: ${response.status}`);
   }
 
   let content = await response.text();
@@ -73,7 +71,7 @@ async function main() {
   console.log('\nDone.');
 }
 
-main().catch((err) => {
+main().catch((err: Error) => {
   console.error(err.message || err);
   process.exit(1);
 });
diff --git a/packages/mcp-server/scripts/post-build.ts b/packages/mcp-server/scripts/post-build.ts
new file mode 100644
index 00000000000..49ffe584993
--- /dev/null
+++ b/packages/mcp-server/scripts/post-build.ts
@@ -0,0 +1,39 @@
+/**
+ * Post-build step: copy JSON data files into dist/ and make the CLI entry executable.
+ *
+ * Replaces `rsync` + `chmod` with a cross-platform Node.js solution.
+ *
+ * Usage:
+ *   npm run build:post
+ */
+
+import { cpSync, chmodSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { glob } from 'glob';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const PKG_ROOT = join(__dirname, '..');
+const SRC_DIR = join(PKG_ROOT, 'src');
+const DIST_DIR = join(PKG_ROOT, 'dist');
+
+// Copy all JSON data files from src/ to dist/, preserving directory structure
+const jsonFiles = await glob('**/*.json', { cwd: SRC_DIR });
+
+for (const file of jsonFiles) {
+  const src = join(SRC_DIR, file);
+  const dest = join(DIST_DIR, file);
+  mkdirSync(dirname(dest), { recursive: true });
+  cpSync(src, dest);
+}
+
+console.log(`Copied ${jsonFiles.length} JSON files to dist/`);
+
+// Make CLI entry point executable (no-op on Windows)
+try {
+  chmodSync(join(DIST_DIR, 'index.js'), 0o755);
+} catch {
+  // chmodSync may fail on Windows — not needed there anyway
+}
diff --git a/packages/mcp-server/scripts/utils/cem.ts b/packages/mcp-server/scripts/utils/cem.ts
index 694ecd1615f..1c883ee4b82 100644
--- a/packages/mcp-server/scripts/utils/cem.ts
+++ b/packages/mcp-server/scripts/utils/cem.ts
@@ -8,8 +8,8 @@
  * reusing getCEM() and snakeCaseToCamelCase() from there instead.
  */
 
-import { readFileSync } from 'fs';
-import { join } from 'path';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import type { CemManifest, CemDeclaration, ComponentApiData } from '../../src/types/index.js';
 import { toPascalCase } from './text.js';
 
diff --git a/packages/mcp-server/scripts/utils/docgen.ts b/packages/mcp-server/scripts/utils/docgen.ts
index 8309c48ae59..5224c8dd51c 100644
--- a/packages/mcp-server/scripts/utils/docgen.ts
+++ b/packages/mcp-server/scripts/utils/docgen.ts
@@ -3,8 +3,8 @@
  * Parses component files for props, methods, and type information.
  */
 
-import { readFileSync } from 'fs';
-import { join } from 'path';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import * as docgen from 'react-docgen-typescript';
 import type { PropItem } from 'react-docgen-typescript';
 import type { TypeInfo, CleanedProp, MethodInfo, MethodParam, ComponentApiData } from '../../src/types/index.js';
diff --git a/packages/mcp-server/src/tools/get_component_api/component-apis.json b/packages/mcp-server/src/tools/get_component_api/component-apis.json
index e95d86f8a6c..51e19b79e6e 100644
--- a/packages/mcp-server/src/tools/get_component_api/component-apis.json
+++ b/packages/mcp-server/src/tools/get_component_api/component-apis.json
@@ -34099,7 +34099,7 @@
   },
   "metadata": {
     "version": "2.20.1",
-    "extractedAt": "2026-03-20T09:28:13.408Z",
+    "extractedAt": "2026-03-27T12:17:02.288Z",
     "componentsCount": 26,
     "webComponentsCount": 161,
     "chartsCount": 12,
diff --git a/packages/mcp-server/src/tools/list_components/descriptions.json b/packages/mcp-server/src/tools/list_components/descriptions.json
index 2769ec359cd..0abec28084f 100644
--- a/packages/mcp-server/src/tools/list_components/descriptions.json
+++ b/packages/mcp-server/src/tools/list_components/descriptions.json
@@ -825,7 +825,7 @@
   },
   "metadata": {
     "version": "2.20.1",
-    "extractedAt": "2026-03-20T09:28:13.408Z",
+    "extractedAt": "2026-03-27T12:17:02.288Z",
     "componentsCount": 26,
     "webComponentsCount": 161,
     "chartsCount": 12,

From c715a995c6918b7d7734df54455f8d519485feed Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Fri, 27 Mar 2026 14:46:52 +0100
Subject: [PATCH 03/16] remove redundant steps from extraction script

---
 .../scripts/extract-component-descriptions.ts | 46 +++++++++----------
 packages/mcp-server/scripts/utils/docgen.ts   | 30 ++++--------
 .../get_component_api/component-apis.json     |  2 +-
 .../tools/list_components/descriptions.json   |  2 +-
 4 files changed, 34 insertions(+), 46 deletions(-)

diff --git a/packages/mcp-server/scripts/extract-component-descriptions.ts b/packages/mcp-server/scripts/extract-component-descriptions.ts
index b1aed5c0640..870b778fc22 100644
--- a/packages/mcp-server/scripts/extract-component-descriptions.ts
+++ b/packages/mcp-server/scripts/extract-component-descriptions.ts
@@ -23,7 +23,7 @@ import {
   AI_CATEGORIES,
 } from '../src/utils/categories.js';
 import { findComponentCategory } from './utils/text.js';
-import { extractDescription, extractFullComponentApi } from './utils/docgen.js';
+import { extractFullComponentApi } from './utils/docgen.js';
 import { loadCemData, enrichWithCem } from './utils/cem.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -53,13 +53,12 @@ async function main() {
     if (!findComponentCategory(name, REACT_COMPONENT_CATEGORIES)) {
       missingComponents.push(name);
     }
-    const desc = extractDescription(file);
-    if (desc) {
-      descriptions.components[name] = { description: desc, package: '@ui5/webcomponents-react' };
-    }
-    const api = extractFullComponentApi(file, '@ui5/webcomponents-react', name, __dirname);
-    if (api) {
-      componentApis.components[name] = api;
+    const result = extractFullComponentApi(file, '@ui5/webcomponents-react', name, __dirname);
+    if (result) {
+      if (result.description) {
+        descriptions.components[name] = { description: result.description, package: '@ui5/webcomponents-react' };
+      }
+      componentApis.components[name] = result.api;
     }
   }
 
@@ -77,11 +76,11 @@ async function main() {
       description: wcDescriptions[name] || 'UI5 Web Component wrapper',
       package: '@ui5/webcomponents-react',
     };
-    const api = extractFullComponentApi(file, '@ui5/webcomponents-react', name, __dirname);
-    if (api) {
+    const result = extractFullComponentApi(file, '@ui5/webcomponents-react', name, __dirname);
+    if (result) {
       const cemEntry = cemLookup.get(name);
-      if (cemEntry) enrichWithCem(api, cemEntry.decl);
-      componentApis.webComponents[name] = api;
+      if (cemEntry) enrichWithCem(result.api, cemEntry.decl);
+      componentApis.webComponents[name] = result.api;
     }
   }
 
@@ -92,13 +91,12 @@ async function main() {
     if (!findComponentCategory(name, CHART_CATEGORIES)) {
       missingComponents.push(name);
     }
-    const desc = extractDescription(file);
-    if (desc) {
-      descriptions.charts[name] = { description: desc, package: '@ui5/webcomponents-react-charts' };
-    }
-    const api = extractFullComponentApi(file, '@ui5/webcomponents-react-charts', name, __dirname);
-    if (api) {
-      componentApis.charts[name] = api;
+    const result = extractFullComponentApi(file, '@ui5/webcomponents-react-charts', name, __dirname);
+    if (result) {
+      if (result.description) {
+        descriptions.charts[name] = { description: result.description, package: '@ui5/webcomponents-react-charts' };
+      }
+      componentApis.charts[name] = result.api;
     }
   }
 
@@ -109,15 +107,15 @@ async function main() {
     if (!findComponentCategory(name, AI_CATEGORIES)) {
       missingComponents.push(name);
     }
+    const result = extractFullComponentApi(file, '@ui5/webcomponents-ai-react', name, __dirname);
     descriptions.ai[name] = {
-      description: aiDescriptions[name] || extractDescription(file) || 'AI-enhanced component',
+      description: aiDescriptions[name] || result?.description || 'AI-enhanced component',
       package: '@ui5/webcomponents-ai-react',
     };
-    const api = extractFullComponentApi(file, '@ui5/webcomponents-ai-react', name, __dirname);
-    if (api) {
+    if (result) {
       const cemEntry = cemLookup.get(name);
-      if (cemEntry) enrichWithCem(api, cemEntry.decl);
-      componentApis.ai[name] = api;
+      if (cemEntry) enrichWithCem(result.api, cemEntry.decl);
+      componentApis.ai[name] = result.api;
     }
   }
 
diff --git a/packages/mcp-server/scripts/utils/docgen.ts b/packages/mcp-server/scripts/utils/docgen.ts
index 5224c8dd51c..92a1dd143c8 100644
--- a/packages/mcp-server/scripts/utils/docgen.ts
+++ b/packages/mcp-server/scripts/utils/docgen.ts
@@ -189,36 +189,23 @@ export function extractDomRefMethods(componentName: string, packagePath: string,
   }
 }
 
-/**
- * Extract JSDoc description from a component file using react-docgen-typescript.
- */
-export function extractDescription(filePath: string): string | null {
-  try {
-    const componentDocs = parser.parse(filePath);
-    if (componentDocs.length > 0 && componentDocs[0].description) {
-      return cleanJSDocDescription(componentDocs[0].description);
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Extract full component API data using react-docgen-typescript.
  * Returns complete props, methods, types, and JSDoc metadata.
+ * Also returns the cleaned JSDoc description separately to avoid a second parse.
  */
 export function extractFullComponentApi(
   filePath: string,
   packageName: string,
   componentName: string,
   scriptDir: string,
-): ComponentApiData | null {
+): { api: ComponentApiData; description: string | null } | null {
   try {
     const componentDocs = parser.parse(filePath);
     if (componentDocs.length === 0) return null;
 
     const doc = componentDocs[0];
+    const description = doc.description ? cleanJSDocDescription(doc.description) : null;
 
     const cleanedProps: Record<string, CleanedProp> = {};
     if (doc.props) {
@@ -264,10 +251,13 @@ export function extractFullComponentApi(
       '\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.';
 
     return {
-      package: packageName,
-      description: descriptionWithNote,
-      props: cleanedProps,
-      methods: cleanedMethods,
+      api: {
+        package: packageName,
+        description: descriptionWithNote,
+        props: cleanedProps,
+        methods: cleanedMethods,
+      },
+      description,
     };
   } catch {
     return null;
diff --git a/packages/mcp-server/src/tools/get_component_api/component-apis.json b/packages/mcp-server/src/tools/get_component_api/component-apis.json
index 51e19b79e6e..b433785cd3a 100644
--- a/packages/mcp-server/src/tools/get_component_api/component-apis.json
+++ b/packages/mcp-server/src/tools/get_component_api/component-apis.json
@@ -34099,7 +34099,7 @@
   },
   "metadata": {
     "version": "2.20.1",
-    "extractedAt": "2026-03-27T12:17:02.288Z",
+    "extractedAt": "2026-03-27T13:42:54.707Z",
     "componentsCount": 26,
     "webComponentsCount": 161,
     "chartsCount": 12,
diff --git a/packages/mcp-server/src/tools/list_components/descriptions.json b/packages/mcp-server/src/tools/list_components/descriptions.json
index 0abec28084f..731ce08171a 100644
--- a/packages/mcp-server/src/tools/list_components/descriptions.json
+++ b/packages/mcp-server/src/tools/list_components/descriptions.json
@@ -825,7 +825,7 @@
   },
   "metadata": {
     "version": "2.20.1",
-    "extractedAt": "2026-03-27T12:17:02.288Z",
+    "extractedAt": "2026-03-27T13:42:54.707Z",
     "componentsCount": 26,
     "webComponentsCount": 161,
     "chartsCount": 12,

From 822397c79dd385ece8e6de9a1dfbeb8b6fbbed0a Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Fri, 27 Mar 2026 16:14:56 +0100
Subject: [PATCH 04/16] remove meaningless mdx docs

---
 packages/mcp-server/scripts/bundle-docs.ts    |  6 +++
 .../get_component_api/component-apis.json     |  2 +-
 .../documentation_sections.json               | 38 -------------------
 .../get_documentation/get_documentation.ts    |  2 -
 .../tools/list_components/descriptions.json   |  2 +-
 5 files changed, 8 insertions(+), 42 deletions(-)

diff --git a/packages/mcp-server/scripts/bundle-docs.ts b/packages/mcp-server/scripts/bundle-docs.ts
index a28e951d6ca..04a0772371f 100644
--- a/packages/mcp-server/scripts/bundle-docs.ts
+++ b/packages/mcp-server/scripts/bundle-docs.ts
@@ -11,6 +11,12 @@
  * TODO: Re-evaluate adding "UXC Integration" to documentation_sections.json
  * once the UXC docs page has bundleable content (currently metadata-only,
  * removed because fetchContent would return "not available locally").
+ *
+ * TODO: Re-add "Patterns > Docs" (docs/Patterns.mdx) and
+ * "Patterns > SelectionAssistant" (patterns/selection-assistant/SelectionAssistant.mdx)
+ * once their MDX content is converted to LLM-friendly markdown. Currently both
+ * files render all meaningful content via imported React components (<UXCIntegration/>,
+ * <InputSelectionAssistant/>, etc.) which are opaque to an LLM consumer.
  */
 
 import type { DocumentationData } from '../src/types/index.js';
diff --git a/packages/mcp-server/src/tools/get_component_api/component-apis.json b/packages/mcp-server/src/tools/get_component_api/component-apis.json
index b433785cd3a..0d57d1e7f46 100644
--- a/packages/mcp-server/src/tools/get_component_api/component-apis.json
+++ b/packages/mcp-server/src/tools/get_component_api/component-apis.json
@@ -34099,7 +34099,7 @@
   },
   "metadata": {
     "version": "2.20.1",
-    "extractedAt": "2026-03-27T13:42:54.707Z",
+    "extractedAt": "2026-03-27T14:57:39.727Z",
     "componentsCount": 26,
     "webComponentsCount": 161,
     "chartsCount": 12,
diff --git a/packages/mcp-server/src/tools/get_documentation/documentation_sections.json b/packages/mcp-server/src/tools/get_documentation/documentation_sections.json
index f3eeac8d0e9..5543b768a15 100644
--- a/packages/mcp-server/src/tools/get_documentation/documentation_sections.json
+++ b/packages/mcp-server/src/tools/get_documentation/documentation_sections.json
@@ -229,44 +229,6 @@
           ]
         }
       ]
-    },
-    {
-      "name": "Patterns",
-      "description": "Architecture patterns, best practices, and experimental features for common use cases and advanced component interactions.",
-      "subsections": [
-        {
-          "name": "Docs",
-          "description": "Architectural examples and design patterns demonstrating common use cases, component interactions, and composition strategies.",
-          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/patterns-docs--docs",
-          "sourcePath": "docs/Patterns.mdx",
-          "content": [
-            "Architectural examples",
-            "Common use cases",
-            "Component interactions",
-            "Master-detail views",
-            "Form handling",
-            "Data management strategies",
-            "Composition patterns"
-          ],
-          "tags": ["patterns", "architecture", "best-practices", "examples", "use-cases", "component-patterns"],
-          "localPath": "docs--Patterns.mdx"
-        },
-        {
-          "name": "SelectionAssistant (Exp)",
-          "description": "Experimental pattern for advanced multi-selection scenarios with filtering and search capabilities.",
-          "link": "https://ui5.github.io/webcomponents-react/v2/?path=/docs/patterns-selectionassistant-experimental--docs",
-          "sourcePath": "patterns/selection-assistant/SelectionAssistant.mdx",
-          "content": [
-            "Experimental multi-selection pattern",
-            "Advanced filtering",
-            "Search capabilities",
-            "Selection handling",
-            "Component state management"
-          ],
-          "tags": ["patterns", "experimental", "selection", "multi-select", "advanced-features", "component-patterns"],
-          "localPath": "patterns--selection-assistant--SelectionAssistant.mdx"
-        }
-      ]
     }
   ]
 }
diff --git a/packages/mcp-server/src/tools/get_documentation/get_documentation.ts b/packages/mcp-server/src/tools/get_documentation/get_documentation.ts
index a56252a5206..f2b6c2989e8 100644
--- a/packages/mcp-server/src/tools/get_documentation/get_documentation.ts
+++ b/packages/mcp-server/src/tools/get_documentation/get_documentation.ts
@@ -368,8 +368,6 @@ export const getDocumentationTool = {
         'Knowledge Base > Server Side Rendering',
         'Knowledge Base > Styling',
         'Knowledge Base > Accessibility',
-        'Patterns > Docs',
-        'Patterns > SelectionAssistant (Exp)',
       ])
       .optional()
       .describe(
diff --git a/packages/mcp-server/src/tools/list_components/descriptions.json b/packages/mcp-server/src/tools/list_components/descriptions.json
index 731ce08171a..c3ae313bebd 100644
--- a/packages/mcp-server/src/tools/list_components/descriptions.json
+++ b/packages/mcp-server/src/tools/list_components/descriptions.json
@@ -825,7 +825,7 @@
   },
   "metadata": {
     "version": "2.20.1",
-    "extractedAt": "2026-03-27T13:42:54.707Z",
+    "extractedAt": "2026-03-27T14:57:39.727Z",
     "componentsCount": 26,
     "webComponentsCount": 161,
     "chartsCount": 12,

From c4a93b61ae07a0df5caa86d03643ea9bca44e53b Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Fri, 27 Mar 2026 16:48:25 +0100
Subject: [PATCH 05/16] add `create-app` prompt

---
 packages/mcp-server/scripts/bundle-docs.ts    |  10 ++
 packages/mcp-server/src/index.ts              |   5 +
 packages/mcp-server/src/prompts/create-app.ts | 117 ++++++++++++++++++
 3 files changed, 132 insertions(+)
 create mode 100644 packages/mcp-server/src/prompts/create-app.ts

diff --git a/packages/mcp-server/scripts/bundle-docs.ts b/packages/mcp-server/scripts/bundle-docs.ts
index 04a0772371f..6f69a53204f 100644
--- a/packages/mcp-server/scripts/bundle-docs.ts
+++ b/packages/mcp-server/scripts/bundle-docs.ts
@@ -168,6 +168,16 @@ function main() {
 
   writeFileSync(SECTIONS_PATH, JSON.stringify(docsData, null, 2) + '\n');
 
+  // Copy raw project-templates.json for the create-app prompt to read at runtime
+  const templatesJsonSrc = join(MONOREPO_ROOT, 'docs/project-templates.json');
+  const templatesJsonDest = join(DOCS_DIR, 'project-templates.json');
+  try {
+    cpSync(templatesJsonSrc, templatesJsonDest);
+    console.log(`  docs/project-templates.json -> docs/project-templates.json (raw copy)`);
+  } catch (error) {
+    console.warn(`  Failed to copy project-templates.json: ${(error as Error).message}`);
+  }
+
   console.log(`\nBundled ${result.copied} documentation files to docs/`);
   if (result.generated > 0) {
     console.log(`Generated ${result.generated} files from data sources`);
diff --git a/packages/mcp-server/src/index.ts b/packages/mcp-server/src/index.ts
index 879801a3346..78fdbf6541d 100644
--- a/packages/mcp-server/src/index.ts
+++ b/packages/mcp-server/src/index.ts
@@ -11,6 +11,7 @@ import { fileURLToPath } from 'url';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { logger } from './logger.js';
+import { createAppPrompt } from './prompts/create-app.js';
 import * as tools from './tools/index.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -65,6 +66,10 @@ server.registerResource(
 );
 logger.info('Registered llms.txt resource');
 
+// Register prompts
+server.registerPrompt(createAppPrompt.name, createAppPrompt.config, createAppPrompt.callback);
+logger.info('Registered create-app prompt');
+
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
diff --git a/packages/mcp-server/src/prompts/create-app.ts b/packages/mcp-server/src/prompts/create-app.ts
new file mode 100644
index 00000000000..670ff71038a
--- /dev/null
+++ b/packages/mcp-server/src/prompts/create-app.ts
@@ -0,0 +1,117 @@
+/**
+ * @fileoverview create-app MCP prompt
+ * Scaffolds a new UI5 Web Components for React application from an official template.
+ */
+
+import { readFileSync } from 'node:fs';
+import { join, dirname, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { z } from 'zod';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const REPO = 'UI5/webcomponents-react';
+
+interface ProjectTemplate {
+  name: string;
+  variant?: string;
+  framework: string;
+  type: 'template' | 'example';
+  path: string;
+  typescript?: boolean;
+  stackBlitz?: string;
+}
+
+// Load templates at module init — filters for type: "template" only
+let templates: ProjectTemplate[] = [];
+try {
+  const templatesPath = join(__dirname, '..', 'docs', 'project-templates.json');
+  const all: ProjectTemplate[] = JSON.parse(readFileSync(templatesPath, 'utf-8'));
+  templates = all.filter((t) => t.type === 'template');
+} catch {
+  // Bundled JSON not available — prompt will report no templates
+}
+
+/** Derive a short ID from the template path, e.g. "templates/nextjs-app" → "nextjs-app" */
+function templateId(t: ProjectTemplate): string {
+  return basename(t.path);
+}
+
+function templateLabel(t: ProjectTemplate): string {
+  return t.variant ? `${t.name} (${t.variant})` : t.name;
+}
+
+const availableIds = templates.map(templateId);
+const availableList = templates.map((t) => `- \`${templateId(t)}\` — ${templateLabel(t)}`).join('\n');
+
+export const createAppPrompt = {
+  name: 'create-app',
+  config: {
+    title: 'Create App',
+    description:
+      'Scaffold a new UI5 Web Components for React application from an official template using degit.\n\n' +
+      `Available templates:\n${availableList}`,
+    argsSchema: {
+      template: z.string().describe(`Template to use. Available: ${availableIds.join(', ')}`),
+      appName: z.string().describe('Name for the new application directory'),
+    },
+  },
+  callback: ({ template, appName }: { template: string; appName: string }) => {
+    const entry = templates.find((t) => templateId(t) === template);
+
+    if (!entry) {
+      return {
+        messages: [
+          {
+            role: 'user' as const,
+            content: {
+              type: 'text' as const,
+              text: `Unknown template "${template}".\n\n` + `Available templates:\n${availableList}`,
+            },
+          },
+        ],
+      };
+    }
+
+    const label = templateLabel(entry);
+    const degitCmd = `npx degit ${REPO}/${entry.path}#main ${appName}`;
+
+    const text = [
+      `Scaffold a new **${label}** application called \`${appName}\`.`,
+      '',
+      '## Steps',
+      '',
+      `1. Run: \`${degitCmd}\``,
+      `2. \`cd ${appName}\``,
+      `3. Update the \`name\` field in \`package.json\` to \`"${appName}"\``,
+      '4. Run: `npm install`',
+      '5. Start the dev server: `npm run dev`',
+      '',
+      '## Template Details',
+      '',
+      `- **Framework**: ${entry.name}${entry.variant ? ` (${entry.variant})` : ''}`,
+      `- **Language**: ${entry.typescript ? 'TypeScript' : 'JavaScript'}`,
+      `- **GitHub**: https://github.com/${REPO}/tree/main/${entry.path}`,
+      entry.stackBlitz ? `- **StackBlitz**: ${entry.stackBlitz}` : '',
+      '',
+      '## Post-Setup',
+      '',
+      '- ThemeProvider from `@ui5/webcomponents-react` is already configured in the template',
+      "- Import components: `import { Button, Input, Card } from '@ui5/webcomponents-react'`",
+      '- Use `get_component_api` to look up component props, events, and methods',
+      '- Use `get_documentation` for guides on styling, i18n, SSR, and more',
+    ]
+      .filter(Boolean)
+      .join('\n');
+
+    return {
+      messages: [
+        {
+          role: 'user' as const,
+          content: { type: 'text' as const, text },
+        },
+      ],
+    };
+  },
+};

From 4166f8dbcd5766ed87f3d64bef8158fa44567702 Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Mon, 30 Mar 2026 10:23:26 +0200
Subject: [PATCH 06/16] improve AnalyticalTable ressources

---
 .../AnalyticalTable/docs/AnalyticalTable.mdx  |    48 +-
 .../AnalyticalTable/docs/ColumnProperties.md  |    49 +
 packages/mcp-server/.gitignore                |     4 +
 packages/mcp-server/resources/llms.txt        |     2 +-
 .../scripts/extract-component-descriptions.ts |    21 +-
 .../get_component_api/component-apis.json     | 34108 ----------------
 .../get_component_api/get_component_api.ts    |     7 +-
 .../tools/list_components/descriptions.json   |   834 -
 .../mcp-server/src/types/component-api.ts     |     2 +
 9 files changed, 85 insertions(+), 34990 deletions(-)
 create mode 100644 packages/main/src/components/AnalyticalTable/docs/ColumnProperties.md
 delete mode 100644 packages/mcp-server/src/tools/get_component_api/component-apis.json
 delete mode 100644 packages/mcp-server/src/tools/list_components/descriptions.json

diff --git a/packages/main/src/components/AnalyticalTable/docs/AnalyticalTable.mdx b/packages/main/src/components/AnalyticalTable/docs/AnalyticalTable.mdx
index e582c7b94df..886ba09bfd1 100644
--- a/packages/main/src/components/AnalyticalTable/docs/AnalyticalTable.mdx
+++ b/packages/main/src/components/AnalyticalTable/docs/AnalyticalTable.mdx
@@ -1,6 +1,7 @@
 import { ControlsWithNote, DocsHeader, Footer } from '@sb/components';
-import { Canvas, Meta } from '@storybook/addon-docs/blocks';
+import { Canvas, Markdown, Meta } from '@storybook/addon-docs/blocks';
 import * as ComponentStories from './AnalyticalTable.stories';
+import ColumnPropertiesMd from './ColumnProperties.md?raw';
 
 <Meta of={ComponentStories} />
 
@@ -88,50 +89,7 @@ const TableComp = () => {
 
 ## Column Properties
 
-**Required Attributes**
-
-| Attribute  | Type                                                                                                                                                      | Description                                                                                                                                                                                                                    |
-| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `accessor` | `string` OR <br />`(originalRow: Record<string, any>, rowIndex: number, row: RowType,` <br />`parentRows: RowType[], data: Record<string, any>[]) => any` | This `string`/`function` is used to build the data model for your column.<br /><br />**Note**: You can also specify deeply nested values with accessors like `info.hobby` or even `address[0].street`.<br />                   |
-| `id`       | `string`                                                                                                                                                  | Defines the unique ID for the column. It is used by reference in things like sorting, grouping, filtering, etc.<br /><br />**Note:** If no `accessor` is set, or the `accessor` is a function, the `id` property is mandatory. |
-
-**Optional Properties**
-
-| Attribute               | Type                                                                                                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| ----------------------- | --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Header`                | `string` OR<br/>`ComponentType`                                                                     | Can either be `string` or a React component that will be rendered as column header                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `headerLabel`           | `string`                                                                                            | Defines the `aria-label` for the whole column read by screen readers.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `headerTooltip`         | `string`                                                                                            | Tooltip for the column header. If not set, the display text will be the same as the Header if it is a `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| `Cell`                  | `string` OR<br />`ComponentType`<br/>`<CellInstance>`                                               | Custom cell renderer. If set, the table will use this component or render the provided string for every cell, passing all necessary information as props, e.g., the cell value as `props.value`.<br /><br />**Note:**<ul><li>Using a custom component **can impact performance**! If you pass a component, **memoizing it is strongly recommended**, especially for complex components or large datasets.</li><li>For custom elements, text truncation needs to be applied manually. [Here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/data-display-analyticaltable-recipes--docs) you can find out more.</li></ul> |
-| `cellLabel`             | `({cell, instance})`<br/>`=> string`                                                                | Defines a function that receives an object as a parameter, including the cell and table instance, and should return the `aria-label` of the current cell. <br /><br />**Note:** Use this property if there is no textual content available through the dataset (e.g. no `accessor` field available), or if you want to provide additional context when navigating to the respective cell for screen readers.<br /><br />**Note:** To retrieve the internal `aria-label`, utilize the `cell.cellLabel` property.                                                                                                                   |
-| `width`                 | `number`                                                                                            | Defines the column width. If not set, the table will distribute all columns without a width evenly.<br />**Note:** The `width` cannot be less than `minWidth`. Since `minWidth` defaults to 60, set a lower `minWidth` to allow narrower columns.                                                                                                                                                                                                                                                                                                                                                                                 |
-| `minWidth`              | `number`                                                                                            | Minimum width of the column.<br />**Default:** `60`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `maxWidth`              | `number`                                                                                            | Maximum width of the column.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `Filter`                | `ComponentType`                                                                                     | Filter Component to be rendered in the Header                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `disableFilters`        | `boolean`                                                                                           | Disable filters for this column                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `disableGlobalFilter`   | `boolean`                                                                                           | Disable global filtering for this column                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `defaultCanFilter`      | `boolean`                                                                                           | If set to true, this column will be filterable, regardless if it has a valid `accessor`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| `filter`                | `string OR Function`                                                                                | Either a string or a filter function.<br />Supported String Values: <ul><li>`text`</li><li>`exactText`</li><li>`exactTextCase`</li><li>`equals`</li></ul>**Note:** When the standard `Filter` component is used, the filter function is not triggered if the `filterValue` is empty, as the filter is then removed.                                                                                                                                                                                                                                                                                                               |
-| `Aggregated`            | `ComponentType`                                                                                     | Component to render for aggregated cells                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `aggregate`             | `string` OR<br/>`((leafValues,`<br/>`aggregatedValues)`<br/>`=> any)`                               | Aggregation function or string.<br />Supported String Values: <ul><li>`sum`</li><li>`min`</li><li>`max`</li><li>`minMax`</li><li>`average`</li><li>`median`</li><li>`unique`</li><li>`uniqueCount`</li><li>`count`</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `aggregateValue`        | `string` OR<br/>`((values, row,`<br/>`column) => any)`                                              | When attempting to group/aggregate non primitive cell values (eg. arrays of items) you will likely need to resolve a stable primitive value like a number or string to use in normal row aggregations. This property can be used to aggregate or simply access the value to be used in aggregations eg. count-ing the unique number of items in a cell's array value before sum-ing that count across the table                                                                                                                                                                                                                   |
-| `disableGroupBy`        | `boolean`                                                                                           | Disable groupBy for this column                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `defaultCanSort`        | `boolean`                                                                                           | If set to true, this column will be sortable, regardless if it has a valid `accessor`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `disableSortBy`         | `boolean`                                                                                           | Disable sorting for this column                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `sortDescFirst`         | `boolean`                                                                                           | If set to `true`, the first sort direction for this column will be descending instead of ascending.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `sortInverted`          | `boolean`                                                                                           | If set to `true`, the underlying sorting direction will be inverted, but the UI will not.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `sortType`              | `string` OR<br/>`((rowA, rowB,`<br/>`columnId: string,`<br/>`descending: boolean)`<br/>`=> number)` | String or custom **memoized** sort function.<br />Supported String Values: <ul><li>`basic`</li><li>`datetime`</li><li>`alphanumeric`</li></ul>**Default:**`'alphanumeric'`                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `disableResizing`       | `boolean`                                                                                           | Disable resizing for this column                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `hAlign`                | `TextAlign`                                                                                         | Horizontal align of the cell                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `vAlign`                | `VerticalAlign`                                                                                     | Vertical align of the cell                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `scaleWidthModeOptions` | `ScaleWidthModeOptions`                                                                             | Allows passing a custom string for the internal width calculation of custom cells for `scaleWidthMode` `Grow` and `Smart`. More <a href="./?path=/docs/data-display-analyticaltable-recipes--docs#how-to-scale-custom-cells">here</a>                                                                                                                                                                                                                                                                                                                                                                                             |
-| `responsivePopIn`       | `boolean`                                                                                           | Enables the pop-in behavior of the column. When the `responsiveMinWidth` is smaller then the width of the table, the content of each cell will move to the first cell in the row, improving usability on small or mobile devices.<br />**Note:** At least one column must remain visible at all times!                                                                                                                                                                                                                                                                                                                            |
-| `responsiveMinWidth`    | `number`                                                                                            | Defines how the table should react when its width falls below the `responsiveMinWidth`. <ul><li>If `responsivePopIn` is `true` the content of this column will be moved to the first column.</li><li>If `responsivePopIn` is not set or `false` the column will be hidden.</li></ul>                                                                                                                                                                                                                                                                                                                                              |
-| `PopInHeader`           | `string` OR<br/>`ComponentType`                                                                     | Custom pop-in header renderer. If set, the table will call that component for every column that is "popped-in" and pass the table instance as prop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `popinDisplay`          | `AnalyticalTablePopinDisplay`                                                                       | Defines the display of `AnalyticalTable` pop-ins.<br />**Default:** `AnalyticalTablePopinDisplay.Block`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| `disableDragAndDrop`    | `boolean`                                                                                           | Defines if the column is reorderable by dragging and dropping columns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `enableMultiSort`       | `boolean`                                                                                           | Defines whether this column should allow multi-sort.<br /><br /> **Note:** When sorting by a column that does not allow multiple sorting, only the current column is sorted and all other sorted columns are reset.                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `autoResizable`         | `boolean`                                                                                           | Defines whether double-clicking a columns resizer will automatically resize the column to fit the largest cell content of visible rows.<br /><br />**Note:** Only default text content is supported by this option, for custom content it might work as well, but we recommend checking the behavior carefully as the logic can't account for all possible implementations.                                                                                                                                                                                                                                                       |
+<Markdown>{ColumnPropertiesMd}</Markdown>
 
 <br />
 
diff --git a/packages/main/src/components/AnalyticalTable/docs/ColumnProperties.md b/packages/main/src/components/AnalyticalTable/docs/ColumnProperties.md
new file mode 100644
index 00000000000..753ec6d8084
--- /dev/null
+++ b/packages/main/src/components/AnalyticalTable/docs/ColumnProperties.md
@@ -0,0 +1,49 @@
+# AnalyticalTable Column Properties
+
+Each object in the `columns` array configures one column. Do not set `width` unless you need specific sizing — by default the table distributes space evenly.
+
+## Required
+
+| Property   | Type                                                                | Description                                                                                           |
+| ---------- | ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
+| `accessor` | `string` or `(originalRow, rowIndex, row, parentRows, data) => any` | Builds the data model for the column. Supports nested paths like `info.hobby` or `address[0].street`. |
+| `id`       | `string`                                                            | Unique column ID. Mandatory if `accessor` is not set or is a function.                                |
+
+## Optional
+
+| Property                | Type                                                 | Default          | Description                                                                                                                                 |
+| ----------------------- | ---------------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Header`                | `string` or `ComponentType`                          |                  | Column header text or component.                                                                                                            |
+| `headerLabel`           | `string`                                             |                  | `aria-label` for the column header (screen readers).                                                                                        |
+| `headerTooltip`         | `string`                                             |                  | Tooltip for the column header. Defaults to `Header` if it is a string.                                                                      |
+| `Cell`                  | `string` or `ComponentType<CellInstance>`            |                  | Custom cell renderer. Receives cell value as `props.value`. **Must be memoized** for performance.                                           |
+| `cellLabel`             | `({cell, instance}) => string`                       |                  | `aria-label` for individual cells (screen readers).                                                                                         |
+| `width`                 | `number`                                             |                  | Column width in pixels. If not set, the table distributes all columns without a width evenly. Cannot be less than `minWidth`.               |
+| `minWidth`              | `number`                                             | `60`             | Minimum column width.                                                                                                                       |
+| `maxWidth`              | `number`                                             |                  | Maximum column width.                                                                                                                       |
+| `hAlign`                | `TextAlign`                                          |                  | Horizontal cell alignment.                                                                                                                  |
+| `vAlign`                | `VerticalAlign`                                      |                  | Vertical cell alignment.                                                                                                                    |
+| `Popover`               | `ComponentType` or `(instance) => ReactNode`         |                  | Custom header popover renderer. Replaces the internal header popover. Receives table instance with `popoverProps` (`openerRef`, `setOpen`). |
+| `Filter`                | `ComponentType`                                      |                  | Filter component rendered in the header.                                                                                                    |
+| `disableFilters`        | `boolean`                                            |                  | Disable filtering for this column.                                                                                                          |
+| `disableGlobalFilter`   | `boolean`                                            |                  | Exclude this column from global filter.                                                                                                     |
+| `defaultCanFilter`      | `boolean`                                            |                  | Make column filterable even without a valid `accessor`.                                                                                     |
+| `filter`                | `string` or `Function`                               |                  | Filter function. Built-in: `text`, `exactText`, `exactTextCase`, `equals`.                                                                  |
+| `disableSortBy`         | `boolean`                                            |                  | Disable sorting for this column.                                                                                                            |
+| `defaultCanSort`        | `boolean`                                            |                  | Make column sortable even without a valid `accessor`.                                                                                       |
+| `sortDescFirst`         | `boolean`                                            |                  | First sort direction is descending instead of ascending.                                                                                    |
+| `sortInverted`          | `boolean`                                            |                  | Invert underlying sort direction without changing the UI indicator.                                                                         |
+| `sortType`              | `string` or `(rowA, rowB, columnId, desc) => number` | `'alphanumeric'` | Sort function. Built-in: `basic`, `datetime`, `alphanumeric`. **Must be memoized** if a function.                                           |
+| `enableMultiSort`       | `boolean`                                            |                  | Allow multi-sort for this column.                                                                                                           |
+| `disableGroupBy`        | `boolean`                                            |                  | Disable grouping for this column.                                                                                                           |
+| `Aggregated`            | `string` or `ComponentType`                          |                  | Component to render for aggregated cells.                                                                                                   |
+| `aggregate`             | `string` or `(leafValues, aggregatedValues) => any`  |                  | Aggregation function. Built-in: `sum`, `min`, `max`, `minMax`, `average`, `median`, `unique`, `uniqueCount`, `count`.                       |
+| `aggregateValue`        | `string` or `(values, row, column) => any`           |                  | Resolve a primitive value for aggregation from non-primitive cell values.                                                                   |
+| `disableResizing`       | `boolean`                                            |                  | Disable column resizing.                                                                                                                    |
+| `autoResizable`         | `boolean`                                            |                  | Double-click resizer to auto-fit column width to content. Works best with default text content.                                             |
+| `disableDragAndDrop`    | `boolean`                                            |                  | Disable column reordering via drag and drop.                                                                                                |
+| `scaleWidthModeOptions` | `ScaleWidthModeOptions`                              |                  | Custom string for internal width calculation with `scaleWidthMode` `Grow` or `Smart`.                                                       |
+| `responsivePopIn`       | `boolean`                                            |                  | Move column content to the first cell when table width falls below `responsiveMinWidth`. At least one column must remain visible.           |
+| `responsiveMinWidth`    | `number`                                             |                  | Table width threshold for pop-in or hiding. If `responsivePopIn` is true, content moves; otherwise column hides.                            |
+| `PopInHeader`           | `string` or `ComponentType`                          |                  | Custom header for popped-in columns.                                                                                                        |
+| `popinDisplay`          | `AnalyticalTablePopinDisplay`                        | `Block`          | Display style for pop-in content.                                                                                                           |
diff --git a/packages/mcp-server/.gitignore b/packages/mcp-server/.gitignore
index 0b18de06e5e..e2be87beb0d 100644
--- a/packages/mcp-server/.gitignore
+++ b/packages/mcp-server/.gitignore
@@ -4,6 +4,10 @@ dist/
 # Bundled documentation (copied from monorepo at build time)
 docs/
 
+# Generated API data (produced by npm run extract:descriptions)
+src/tools/get_component_api/component-apis.json
+src/tools/list_components/descriptions.json
+
 # TypeScript build info
 tsconfig.tsbuildinfo
 tsconfig.build.tsbuildinfo
diff --git a/packages/mcp-server/resources/llms.txt b/packages/mcp-server/resources/llms.txt
index 01a132e8585..5ee71ed0933 100644
--- a/packages/mcp-server/resources/llms.txt
+++ b/packages/mcp-server/resources/llms.txt
@@ -56,6 +56,6 @@ This server does NOT cover:
 - Slot props require forwarding the `slot` prop to the root element
 - Shadow DOM styling uses `::part()` pseudo-element and CSS variables (`--sapBackgroundColor`, etc.)
 - Components support both React 18 and React 19+
-- Use subpath imports for @ui5/webcomponents-react-base (e.g., `@ui5/webcomponents-react-base/hooks`)
+- Use subpath imports for @ui5/webcomponents-react-<package-refix> (e.g., `@ui5/webcomponents-react-base/hooks`)
 - Web components use proxy attributes (`accessibleName`, `accessibleNameRef`) instead of standard `aria-*` for shadow DOM compatibility
 - When creating a new application, prefer official project templates (Next.js, Vite) over scaffolding from scratch. Use get_documentation({ section: "Project Templates & Examples", fetchContent: true }) to find available templates. Only fall back to generic framework setup if no template matches the user's framework.
diff --git a/packages/mcp-server/scripts/extract-component-descriptions.ts b/packages/mcp-server/scripts/extract-component-descriptions.ts
index 870b778fc22..5fc81765dac 100644
--- a/packages/mcp-server/scripts/extract-component-descriptions.ts
+++ b/packages/mcp-server/scripts/extract-component-descriptions.ts
@@ -11,7 +11,7 @@
  *   npm run extract:descriptions
  */
 
-import { readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { glob } from 'glob';
@@ -119,6 +119,25 @@ async function main() {
     }
   }
 
+  // --- Sub-type documentation (complex prop types) ---
+  const subTypeDocsMap: Record<string, string> = {
+    AnalyticalTable: join(UI5_WCR_PATH, 'packages/main/src/components/AnalyticalTable/docs/ColumnProperties.md'),
+  };
+  for (const [componentName, mdPath] of Object.entries(subTypeDocsMap)) {
+    if (!existsSync(mdPath)) {
+      console.warn(`  subTypeDocs not found: ${mdPath}`);
+      continue;
+    }
+    // Find the component in any category
+    for (const category of ['components', 'webComponents', 'charts', 'ai'] as const) {
+      if (componentApis[category][componentName]) {
+        componentApis[category][componentName].subTypeDocs = readFileSync(mdPath, 'utf-8');
+        console.log(`Attached subTypeDocs for ${componentName}`);
+        break;
+      }
+    }
+  }
+
   // --- Metadata ---
   try {
     const wcrPkg = JSON.parse(readFileSync(join(UI5_WCR_PATH, 'packages/main/package.json'), 'utf-8'));
diff --git a/packages/mcp-server/src/tools/get_component_api/component-apis.json b/packages/mcp-server/src/tools/get_component_api/component-apis.json
deleted file mode 100644
index 0d57d1e7f46..00000000000
--- a/packages/mcp-server/src/tools/get_component_api/component-apis.json
+++ /dev/null
@@ -1,34108 +0,0 @@
-{
-  "components": {
-    "ActionSheet": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ActionSheet` holds a list of buttons from which the user can select to complete an action.\n\nThe children of the action sheet should be `Button` components. Elements in the `ActionSheet` are start-aligned. Actions should be arranged in order of importance, from top to bottom.\n\n### Guidelines\n- Always display text or text and icons for the actions. Do not use icons only.\n- Always provide a Cancel button on mobile phones.\n- Avoid scrolling on action sheets.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text. Will be shown in the header area on phone devices. This prop will be ignored in tablets and desktop browsers.\n\n**Note:** If `header` slot is provided, the `headerText` is ignored."
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header HTML Element. Will be shown in the header area on phone devices. This prop will be ignored in tablets and desktop browsers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--page)."
-        },
-        "children": {
-          "type": {
-            "name": "ReactElement<ButtonPropTypes, string | JSXElementConstructor<any>> | ReactElement<ButtonPropTypes, string | JSXElementConstructor<...>>[]"
-          },
-          "required": false,
-          "description": "Defines the actions of the `ActionSheet`.\n\n__Note:__ Although this slot accepts all HTML Elements, it is strongly recommended that you only use `Buttons` in order to preserve the intended design."
-        },
-        "hideCancelButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Hides the cancel button below the action buttons on mobile devices. No cancel button will be shown on desktop and tablet devices."
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "{ actionSheetMobileContent?: { role?: string; }; }"
-          },
-          "required": false,
-          "description": "Defines internally used accessibility properties/attributes."
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "PopupAccessibleRole | \"None\" | \"Dialog\" | \"AlertDialog\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "Represents no ARIA role."
-              },
-              {
-                "value": "\"Dialog\"",
-                "description": "Represents the ARIA role \"dialog\"."
-              },
-              {
-                "value": "\"AlertDialog\"",
-                "description": "Represents the ARIA role \"alertdialog\"."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Dialog\""
-              },
-              {
-                "value": "\"AlertDialog\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Dialog\""
-          }
-        },
-        "allowTargetOverlap": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines if there is no enough space, the component can be placed\nover the target.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideArrow": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component arrow is hidden.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "horizontalAlign": {
-          "type": {
-            "name": "enum",
-            "raw": "PopoverHorizontalAlign | \"Center\" | \"Start\" | \"End\" | \"Stretch\"",
-            "value": [
-              {
-                "value": "\"Center\"",
-                "description": "Popover is centered."
-              },
-              {
-                "value": "\"Start\"",
-                "description": "Popover is aligned with the start of the target."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Popover is aligned with the end of the target."
-              },
-              {
-                "value": "\"Stretch\"",
-                "description": "Popover is stretched."
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Stretch\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the horizontal alignment of the component.",
-          "defaultValue": {
-            "value": "\"Center\""
-          }
-        },
-        "initialFocus": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the ID of the HTML Element, which will get the initial focus.\n\n**Note:** If an element with `autofocus` attribute is added inside the component,\n`initialFocus` won't take effect."
-        },
-        "modal": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should close when\nclicking/tapping outside the popover.\nIf enabled, it blocks any interaction with the background.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if the element is open\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "opener": {
-          "type": {
-            "name": "string | HTMLElement"
-          },
-          "required": false,
-          "description": "Defines the ID or DOM Reference of the element at which the popover is shown.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
-        },
-        "placement": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Start\" | \"End\" | PopoverPlacement | \"Top\" | \"Bottom\"",
-            "value": [
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Start\"",
-                "description": "Popover will be placed at the start of the reference element."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Popover will be placed at the end of the reference element."
-              },
-              {
-                "value": "\"Top\"",
-                "description": "Popover will be placed at the top of the reference element."
-              },
-              {
-                "value": "\"Bottom\"",
-                "description": "Popover will be placed at the bottom of the reference element."
-              },
-              {
-                "value": "\"Top\""
-              },
-              {
-                "value": "\"Bottom\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines on which side the component is placed at.",
-          "defaultValue": {
-            "value": "\"End\""
-          }
-        },
-        "preventFocusRestore": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "preventInitialFocus": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "resizable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is resizable.\n**Note:** This property is effective only on desktop devices.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "verticalAlign": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Center\" | \"Stretch\" | \"Top\" | \"Bottom\" | PopoverVerticalAlign",
-            "value": [
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Stretch\""
-              },
-              {
-                "value": "\"Top\""
-              },
-              {
-                "value": "\"Bottom\""
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Top\"",
-                "description": "Popover will be placed at the top of the reference control."
-              },
-              {
-                "value": "\"Bottom\"",
-                "description": "Popover will be placed at the bottom of the reference control."
-              },
-              {
-                "value": "\"Stretch\"",
-                "description": "Popover will be streched"
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the vertical alignment of the component.",
-          "defaultValue": {
-            "value": "\"Center\""
-          }
-        },
-        "footer": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the footer HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onBeforeClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, PopupBeforeCloseEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
-        },
-        "onBeforeOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ResponsivePopoverDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "AnalyticalCardHeader": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `AnalyticalCardHeader` is a KPI header, enabling the AnalyticalCard representation. If this header is used, the `Card` should only receive a chart as content and no footer area.\n\n__Note:__ This component should only be used as header for the `Card` component.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "The title of the card"
-        },
-        "titleTextLevel": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Determines the ARIA level of the `titleText`.\n\n__Note:__ Defining a `titleTextLevel` will apply the `aria-level` attribute with a value from 1 to 6.",
-          "defaultValue": {
-            "value": "3"
-          }
-        },
-        "subtitleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "The subtitle of the card"
-        },
-        "trend": {
-          "type": {
-            "name": "enum",
-            "raw": "DeviationIndicator | \"Down\" | \"Up\" | \"None\"",
-            "value": [
-              {
-                "value": "\"Down\""
-              },
-              {
-                "value": "\"Up\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Down\""
-              },
-              {
-                "value": "\"Up\""
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "The direction of the trend arrow. Shows deviation for the value of the main number indicator.",
-          "defaultValue": {
-            "value": "`\"None\"`"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "The numeric value of the main number indicator."
-        },
-        "scale": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the unit of measurement (scaling prefix) for the main indicator.\nFinancial characters can be used for currencies and counters. The International System of Units (SI) prefixes can be used."
-        },
-        "state": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | ValueColor | \"Critical\" | \"Error\" | \"Good\" | \"Neutral\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Critical\"",
-                "description": "Critical value color."
-              },
-              {
-                "value": "\"Error\"",
-                "description": "Error value color."
-              },
-              {
-                "value": "\"Good\"",
-                "description": "Good value color."
-              },
-              {
-                "value": "\"Neutral\"",
-                "description": "Neutral value color."
-              },
-              {
-                "value": "\"None\"",
-                "description": "None value color.\n\n__Note__: \"None\" has the same color as \"Neutral\" but doesn't add the tooltip and accessible-name for the numeric content."
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Error\""
-              },
-              {
-                "value": "\"Good\""
-              },
-              {
-                "value": "\"Neutral\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "The semantic color which represents the state of the main number indicator.\nAvailable options are: <ul> <li><code>None</code></li> <li><code>Error</code></li> <li><code>Critical</code></li> <li><code>Good</code></li> <li><code>Neutral</code></li></ul>\n\n__Note__: \"None\" has the same color as \"Neutral\" but doesn't add the tooltip and accessible-name for the numeric content.",
-          "defaultValue": {
-            "value": "`\"None\"`"
-          }
-        },
-        "description": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Additional text which adds more details to what is shown in the numeric header."
-        },
-        "status": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the status text."
-        },
-        "unitOfMeasurement": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "General unit of measurement for the header. Displayed as side information to the subtitle."
-        },
-        "onClick": {
-          "type": {
-            "name": "MouseEventHandler<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Fired when the `AnalyticalCardHeader` is clicked."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Additional side number indicators. For example \"Deviation\" and \"Target\". Not more than two side indicators should be used.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `NumericSideIndicator` in order to preserve the intended design."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "AnalyticalTable": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `AnalyticalTable` provides a set of convenient functions for responsive table design, including virtualization of rows and columns, infinite scrolling and customizable columns that will, unless otherwise defined, distribute the available space equally among themselves.\nIt also provides several possibilities for working with the data, including sorting, filtering, grouping and aggregation.\n\n__Note:__ The `AnalyticalTable` has some limitations and includes features that do not have a defined design specification.\nTo follow UXC guidelines, please refer to the table below:\n\n| Function / Feature                    | Reason                                                                                                                                                                                                                                                   |\n|---------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| No sticky columns/rows                | Not supported due to technical limitations.                                                                                                                                                                                                              |\n| Pop-in behavior                       | The `sap.ui.table` doesn’t support pop-in behavior (unlike `sap.m.Table`); it’s unclear whether this should be part of the design.                                                                                                                       |\n| `visibleRowCountMode: \"Auto\"`         | `\"AutoWithEmptyRows\"` is preferred. `\"Auto\"` mode can lead to inconsistent table heights depending on the container.                                                                                                                                     |\n| `alwaysShowBusyIndicator`             | Should generally be `true`, only if loading times are over 1 second, the default skeleton loading indicator is sufficient: [Fiori Skeleton Loading](https://www.sap.com/design-system/fiori-design-ios/ui-elements/patterns/skeleton-loading/?external). |\n| `scaleWidthMode`                      | Only the default mode is available out of the box for the `sap.m.Table`; similar behavior to the `\"Grow\"` mode can be achieved in `sap.ui.table` using `autoResizeColumn`.                                                                               |\n| `renderRowSubComponent`               | There is no design/UX concept for this functionality.                                                                                                                                                                                                 |\n| `useIndeterminateRowSelection`        | There is no design/UX concept for this functionality.                                                                                                                                                                                                 |\n| `useRowDisableSelection` (deprecated) | Table rows should not be disabled.                                                                                                                                                                                                                       |\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "columns": {
-          "type": {
-            "name": "AnalyticalTableColumnDefinition[]"
-          },
-          "required": true,
-          "description": "Defines the columns array where you can define the configuration for each column.\n\n__Must be memoized!__"
-        },
-        "data": {
-          "type": {
-            "name": "Record<string, any>[]"
-          },
-          "required": true,
-          "description": "The data array that you want to display on the table.\n\n__Must be memoized!__"
-        },
-        "header": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "Component or text rendered in the header section of the `AnalyticalTable`.\n\n__Note:__ If not set, it will be hidden."
-        },
-        "extension": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "Extension section of the Table. If not set, no extension area will be rendered"
-        },
-        "minRows": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The minimum number of rows that are displayed. If the data contains fewer entries than `minRows`, it will be filled with empty rows.\n\n__Note:__\n- To prevent the height of the table from jumping when e.g. filtering or fetching data, it's recommended setting `minRows` to the same value as `visibleRows`.\n- Values less than 1 are __not__ supported!",
-          "defaultValue": {
-            "value": "5"
-          }
-        },
-        "visibleRowCountMode": {
-          "type": {
-            "name": "enum",
-            "raw": "AnalyticalTableVisibleRowCountMode | \"Fixed\" | \"Auto\" | \"AutoWithEmptyRows\" | \"Interactive\"",
-            "value": [
-              {
-                "value": "\"Fixed\"",
-                "description": "The number of visible rows displayed is defined by the `visibleRows` prop. If the prop is not set, 15 rows will be shown."
-              },
-              {
-                "value": "\"Auto\"",
-                "description": "The number of visible rows depends on the height of the surrounding container. Since this mode can cause the table height to change when filtering, fetching data, etc., we recommend using the `\"AutoWithEmptyRows\"` mode instead.\n\n__Note:__ It's recommended to use a fixed height for the outer container.\n\n__Note:__ When this is active, `visibleRows` prop has no effect."
-              },
-              {
-                "value": "\"AutoWithEmptyRows\"",
-                "description": "The number of rows displayed depends on the height of the surrounding container, if not enough visible rows are available, empty rows are displayed.\n\n__Note:__ It's recommended to use a fixed height for the outer container.\n\n__Note:__ When this is active, `visibleRows` prop has no effect."
-              },
-              {
-                "value": "\"Interactive\"",
-                "description": "Adds a resizer to the bottom of the table to dynamically add or remove visible rows.\nThe initial number of rows is defined by the `visibleRows` prop."
-              },
-              {
-                "value": "\"Fixed\""
-              },
-              {
-                "value": "\"Auto\""
-              },
-              {
-                "value": "\"AutoWithEmptyRows\""
-              },
-              {
-                "value": "\"Interactive\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines how the table will render rows.\n\n- __\"Fixed\":__ The table always has as many rows as defined in the `visibleRows` prop.\n- __\"Auto\":__ The number of visible rows depends on the height of the surrounding container. Since this mode can cause the table height to change when filtering, fetching data, etc., we recommend using the `\"AutoWithEmptyRows\"` mode instead.\n- __\"AutoWithEmptyRows\":__ The number of rows displayed depends on the height of the surrounding container, if not enough visible rows are available, empty rows are displayed.\n- __\"Interactive\":__ Adds a resizer to the bottom of the table to dynamically add or remove visible rows. The initial number of rows is defined by the `visibleRows` prop.\n\n__Note:__ When `\"Auto\"` or `\"AutoWithEmptyRows\"` is enabled, we recommend using a fixed height for the parent container.",
-          "defaultValue": {
-            "value": "\"Fixed\""
-          }
-        },
-        "additionalEmptyRowsCount": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Specifies the number of additional empty rows added to the bottom of a table that is normally __non__ scrollable.\nUse this prop if you want to ensure that the table is scrollable.\n\n__Note:__ It's recommended to use this prop only if `infiniteScroll` is applied and where assessing scrollability is not possible across various resolutions or datasets.\nE.g., when using `visibleRowCountMode` with values `\"Auto\"` or `\"AutoWithEmptyRows\"`.\n\n__Note:__ This prop has no effect if the table is already scrollable without additional empty rows."
-        },
-        "visibleRows": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The number of rows visible without going into overflow.\n\n__Note:__\n- If the data contains more entries than the `visibleRow` count, a vertical scrollbar is rendered and the table goes into overflow.\n- To prevent the height of the table from jumping when e.g. filtering or fetching data, it's recommended setting `minRows` to the same value as `visibleRows`.",
-          "defaultValue": {
-            "value": "15"
-          }
-        },
-        "adjustTableHeightOnPopIn": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the row height of popped-in columns should be considered when calculating the body height of the table.\n\n__Note:__ If set so `true` the table will change its height depending on whether columns are popped in or not."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether a loading indicator should be shown.\n\n__Note:__ If the data array is not empty and loading is set to `true` a `BusyIndicator` will be displayed on top of the table, otherwise a skeleton placeholder will be shown. You can control this behavior via the `alwaysShowBusyIndicator` prop."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "showOverlay": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Setting this prop to `true` will show an overlay on top of the AnalyticalTable content preventing users from interacting with it."
-        },
-        "alwaysShowBusyIndicator": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "If `true`, always shows the `BusyIndicator` component when loading instead of the skeleton loader.\n\n__We recommend setting this prop to `true` when loading times are under 1 second.__"
-        },
-        "noDataText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text shown if the data array is empty or a filtered table doesn't return results.\n\n__Note:__ If `noDataText` isn't set, the default text displayed is \"No data\". For filtered tables, it will show \"No data found. Try adjusting the filter settings.\" instead."
-        },
-        "rowHeight": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the height of the rows and header row.\n\n__Note:__ This prop overrides the default height. If you want to use the default height after you have set a custom height, you will have to remove this prop and remount the component.\n\n__Note:__ To preserve the intended design, it is not recommended to set a row height with active elements such as buttons below `32px` for content density \"Compact\" and `44px` for content density \"Cozy\"."
-        },
-        "headerRowHeight": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the height of the header row.\n\n__Note:__ If this property is set, it overwrites the height set in `rowHeight` for the header row.\n\n__Note:__ This prop overrides the default height. If you want to use the default height after you have set a custom height, you will have to remove this prop and remount the component."
-        },
-        "retainColumnWidth": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the table should retain its column width, when a column has been manually resized and the container width has changed."
-        },
-        "alternateRowColor": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the table should display rows with alternating row colors."
-        },
-        "withNavigationHighlight": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the table should add an extra column at the end of the rows for displaying a navigation highlight."
-        },
-        "withRowHighlight": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the table should add an extra column at the start of the rows for displaying row highlights, based on the `highlightField` prop.\n\n__Note:__ When enabled, the table automatically adds a column with `accessor=\"status\"`. If you have a custom column using this accessor, change the `highlightField` prop to a different value to avoid conflicts."
-        },
-        "highlightField": {
-          "type": {
-            "name": "string | ((row: RowType) => HighlightColor)"
-          },
-          "required": false,
-          "description": "Accessor for showing the row highlights. Only taken into account when `withRowHighlight` is set.\n\nThe value of this prop can either be a `string` pointing to a `ValueState` or an `IndicationColor` in your dataset\nor an accessor function which should return a `ValueState` or an `IndicationColor`.\n\n__Note:__ If a function is used, it __must be memoized!__\n@since 1.26.0",
-          "defaultValue": {
-            "value": "\"status\""
-          }
-        },
-        "filterable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether columns are filterable.\n\n__Note:__ The table is implementing \"top-down\" (parent/root node first) filtering."
-        },
-        "sortable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether columns are sortable.",
-          "defaultValue": {
-            "value": "true"
-          }
-        },
-        "groupable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether columns are groupable.\n\n__Note:__ This prop has no effect when `isTreeTable` is true or `renderRowSubComponent` is set.\n\n__Note:__ It is not recommended to use grouping in combination with `infiniteScroll` as there is no concept for this configuration."
-        },
-        "groupBy": {
-          "type": {
-            "name": "string[]"
-          },
-          "required": false,
-          "description": "Group table rows by adding the column's `accessor` or `id` to the array.\n\n__Must be memoized!__\n\n__Note:__ This prop has no effect when `isTreeTable` is true or `renderRowSubComponent` is set."
-        },
-        "selectionBehavior": {
-          "type": {
-            "name": "enum",
-            "raw": "AnalyticalTableSelectionBehavior | \"Row\" | \"RowOnly\" | \"RowSelector\"",
-            "value": [
-              {
-                "value": "\"Row\"",
-                "description": "A selection column is rendered along with the normal columns. The whole row is selectable."
-              },
-              {
-                "value": "\"RowOnly\"",
-                "description": "No selection column is rendered along with the normal columns. The whole row is selectable."
-              },
-              {
-                "value": "\"RowSelector\"",
-                "description": "The row is only selectable by clicking on the corresponding field in the selection column."
-              },
-              {
-                "value": "\"Row\""
-              },
-              {
-                "value": "\"RowOnly\""
-              },
-              {
-                "value": "\"RowSelector\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the selection behavior of the table.\n\n- __\"Row\":__ A selection column is rendered along with the normal columns. The whole row is selectable.\n- __\"RowOnly\":__ No selection column is rendered along with the normal columns. The whole row is selectable.\n- __\"RowSelector\":__ The row is only selectable by clicking on the corresponding field in the selection column.\n\n__Default:__ `\"Row\"`"
-        },
-        "selectionMode": {
-          "type": {
-            "name": "enum",
-            "raw": "AnalyticalTableSelectionMode | \"None\" | \"Single\" | \"Multiple\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "The rows are not selectable."
-              },
-              {
-                "value": "\"Single\"",
-                "description": "Only a single row is selectable. Clicking on another row will unselect the previously selected row."
-              },
-              {
-                "value": "\"Multiple\"",
-                "description": "Multiple rows are selectable."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Single\""
-              },
-              {
-                "value": "\"Multiple\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the `SelectionMode` of the table.\n\n- __\"None\":__ The rows are not selectable.\n- __\"Single\":__ You can select only one row at once. Clicking on another row will unselect the previously selected row.\n- __\"Multiple\":__ You can select multiple rows.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "scaleWidthMode": {
-          "type": {
-            "name": "enum",
-            "raw": "AnalyticalTableScaleWidthMode | \"Default\" | \"Smart\" | \"Grow\"",
-            "value": [
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Smart\""
-              },
-              {
-                "value": "\"Grow\""
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Smart\""
-              },
-              {
-                "value": "\"Grow\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the column growing behaviour. Possible Values:\n\n- **Default**: The available space of the table is distributed evenly for columns without fixed width. If the minimum width of all columns is reached, horizontal scrolling will be enabled.\n- **Smart**: Every column gets the space it needs for displaying the full header text. If all header texts need more space than the available table width, horizontal scrolling will be enabled. If there is space left, columns with a long text will get more space until there is no more table space left.\n- **Grow**: Every column gets the space it needs for displaying its full header text and full text content of all cells. If it requires more space than the table has, horizontal scrolling will be enabled. To prevent huge header text from polluting the table, a max-width of 700px is applied to each column. It can be overwritten by setting the respective column property.\n\n__Note:__\n- Columns without data `accessor` are ignored by the `Smart` and `Grow` modes. You can use the `scaleWidthModeOptions` property on the column definition to add custom strings for the internal width calculation.\n- For performance reasons, the `Smart` and `Grow` modes base their calculation for table cell width on a subset of column cells. If the first 20 cells of a column are significantly smaller than the rest of the column cells, the content may still not be fully displayed for all cells.\n- Only the default mode is available out of the box for the `sap.m.Table`; similar behavior to the `\"Grow\"` mode can be achieved in `sap.ui.table` using `autoResizeColumn`.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "scaleXFactor": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the number of the CSS `scaleX(sx: number)` function. `sx` is representing the abscissa of the scaling vector."
-        },
-        "columnOrder": {
-          "type": {
-            "name": "string[]"
-          },
-          "required": false,
-          "description": "Defines the columns order by their `accessor` or `id`.\n\n__Must be memoized!__"
-        },
-        "infiniteScroll": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether infinite scroll is active.\n\n__Note:__ It is not recommended to use this prop in combination with a grouped table, as there is no concept for this configuration.\n\n__Note:__ To prevent the table state from resetting when the data is updated, please see [this recipe](https://ui5.github.io/webcomponents-react/v2/?path=/docs/data-display-analyticaltable-recipes--docs#how-to-stop-the-table-state-from-automatically-resetting-when-the-data-changes)."
-        },
-        "infiniteScrollThreshold": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The `infiniteScrollThreshold` defines at how many remaining rows the `onLoadMore` event should be fired.\n\nExample: Your initial dataset consists of 50 entries and you want to load more data when the user scrolled to the 40th row. Then you should set the `infiniteScrollThreshold` to 10.",
-          "defaultValue": {
-            "value": "20"
-          }
-        },
-        "globalFilterValue": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value that should be filtered on across all rows.\n\n__Note:__ This prop is not supported for tree-tables. You can enable it by creating your own global-filter function. You can find out more about this in the [react-table v7 documentation](https://github.com/TanStack/table/blob/v7/docs/src/pages/docs/api/useGlobalFilter.md)."
-        },
-        "reactTableOptions": {
-          "type": {
-            "name": "Record<string, unknown>"
-          },
-          "required": false,
-          "description": "Additional options which will be passed to [v7 react-table´s useTable hook](https://github.com/TanStack/table/blob/v7/docs/src/pages/docs/api/useTable.md#table-options)\n\n__Must be memoized!__"
-        },
-        "tableHooks": {
-          "type": {
-            "name": "((hooks: ReactTableHooks) => void)[]"
-          },
-          "required": false,
-          "description": "You can use this prop to add custom hooks to the table.\n\n__Must be memoized!__",
-          "defaultValue": {
-            "value": "[]"
-          }
-        },
-        "subRowsKey": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the key for nested rows.\n\n__Note__: You can also specify deeply nested sub-rows with accessors like `values.subRows`.",
-          "defaultValue": {
-            "value": "\"subRows\""
-          }
-        },
-        "selectedRowIds": {
-          "type": {
-            "name": "Record<string, boolean>"
-          },
-          "required": false,
-          "description": "The key must consist of a valid `rowId` like `{ 2: true }` or `{ '0.2.0': true }` for nested rows.\n\n__Note:__ This prop updates the internal table state and must therefore be memoized!"
-        },
-        "isTreeTable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the table should act as tree-table."
-        },
-        "overscanCountHorizontal": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The amount of columns to load both behind and ahead of the current window range.",
-          "defaultValue": {
-            "value": "5"
-          }
-        },
-        "overscanCount": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The amount of rows to load both behind and ahead of the current window range."
-        },
-        "renderRowSubComponent": {
-          "type": {
-            "name": "(row: RowType) => ReactNode"
-          },
-          "required": false,
-          "description": "Defines the subcomponent that should be displayed below each row.\n\n__Must be memoized!__\n\n__Note:__\n- __There is no design concept regarding this functionality!__\n- When rendering active elements inside the subcomponent, make sure to add the `data-subcomponent-active-element' attribute, otherwise focus behavior won't be consistent.\n- Subcomponents can affect performance, especially when used in a tree table (`isTreeTable={true}`). If you face performance issues, please try memoizing your subcomponent."
-        },
-        "subComponentsBehavior": {
-          "type": {
-            "name": "enum",
-            "raw": "AnalyticalTableSubComponentsBehavior | \"Expandable\" | \"Visible\" | \"IncludeHeight\" | \"IncludeHeightExpandable\"",
-            "value": [
-              {
-                "value": "\"Expandable\"",
-                "description": "Render subcomponents as expandable container of each row."
-              },
-              {
-                "value": "\"Visible\"",
-                "description": "Render subcomponents below each row."
-              },
-              {
-                "value": "\"IncludeHeight\"",
-                "description": "Render subcomponents below each row. The height of each initially visible subcomponent (defined by `visibleRows`) is taken into account when defining the body height of the table.\n\n__Note:__ `AnalyticalTableVisibleRowCountMode.Interactive` is not supported with this mode."
-              },
-              {
-                "value": "\"IncludeHeightExpandable\"",
-                "description": "Render subcomponents as expandable container of each row. The height of each expanded subcomponent of visible rows (defined by `visibleRows`) is taken into account when defining the body height of the table, so that the height of the table changes when a subcomponent is expanded/collapsed.\n\n__Note:__ This mode can lead to performance degradation, please use with caution!\n__Note:__ `AnalyticalTableVisibleRowCountMode.Interactive` is not supported with this mode."
-              },
-              {
-                "value": "\"Expandable\""
-              },
-              {
-                "value": "\"Visible\""
-              },
-              {
-                "value": "\"IncludeHeight\""
-              },
-              {
-                "value": "\"IncludeHeightExpandable\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the rendering and height calculation behavior of subcomponents when `renderRowSubComponent` is used.\n\n- __\"Expandable\":__ Render subcomponents as expandable container of each row.\n- __\"Visible\":__ Render subcomponents below each row.\n- __\"IncludeHeight\":__ Render subcomponents below each row. The height of each initially visible subcomponent (defined by `visibleRows`) is taken into account when defining the body height of the table.\n- __\"IncludeHeightExpandable\":__ Render subcomponents as expandable container of each row. The height of each expanded subcomponent of visible rows (defined by `visibleRows`) is taken into account when defining the body height of the table, so that the height of the table changes when a subcomponent is expanded/collapsed. (since: v1.23.0)\n@since 1.19.0",
-          "defaultValue": {
-            "value": "\"Expandable\""
-          }
-        },
-        "markNavigatedRow": {
-          "type": {
-            "name": "(row: RowType) => boolean"
-          },
-          "required": false,
-          "description": "This callback can be used to programmatically show an indicator for navigated rows. It has no effect if `withNavigationHighlight` is not set.\n\n__Must be memoized!__"
-        },
-        "onSort": {
-          "type": {
-            "name": "(e: CustomEvent<{ column: ColumnType; sortDirection: string; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when the sorting of the rows changes."
-        },
-        "onGroup": {
-          "type": {
-            "name": "(e: CustomEvent<{ column: ColumnType; groupedColumns: string[]; isGrouped: boolean; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when the grouping of the rows changes."
-        },
-        "onRowSelect": {
-          "type": {
-            "name": "(e: CustomEvent<{ row?: RowType; isSelected?: boolean; allRowsSelected: boolean; allVisibleRowsSelected: boolean; rowsById: Record<string, RowType>; selectedRowIds: Record<string, boolean>; nativeDetail: number; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when a row is selected or unselected."
-        },
-        "onRowClick": {
-          "type": {
-            "name": "(e: OnRowClickEvent) => void"
-          },
-          "required": false,
-          "description": "Fired when a row is clicked"
-        },
-        "onRowExpandChange": {
-          "type": {
-            "name": "(e: CustomEvent<{ row: RowType; column: ColumnType; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when a row is expanded or collapsed"
-        },
-        "onColumnsReorder": {
-          "type": {
-            "name": "(e: CustomEvent<{ columnsNewOrder: ColumnType[]; column: ColumnType; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when the columns order is changed."
-        },
-        "onLoadMore": {
-          "type": {
-            "name": "(e: CustomEvent<{ rowCount: number; totalRowCount: number; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `infiniteScrollThreshold` is reached.\n\n__Note:__ When used in a vertically resizable table (`visibleRowCountMode: AnalyticalTableVisibleRowCountMode.Interactive`), the event is also fired if all available rows are displayed after resizing.\nYou can distinguish between the scroll and custom event by checking the `event.type`.\n@param e.detail.rowCount - The number of rows\n@param e.detail.totalRowCount - The total number of rows, including sub-rows"
-        },
-        "onTableScroll": {
-          "type": {
-            "name": "(e: CustomEvent<{ rows: RowType[]; rowElements: HTMLCollection; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when the body of the table is scrolled.\n\n__Note:__ This callback __must be memoized__! Since it is triggered on __every scroll event__,\nnon-memoized or expensive calculations can have a __huge impact on performance__ and cause visible lag.\nThrottling or debouncing is always recommended to reduce performance overhead."
-        },
-        "onAutoResize": {
-          "type": {
-            "name": "(e: OnAutoResizeMouseEvent) => void"
-          },
-          "required": false,
-          "description": "Fired when the table is resized by double-clicking the Resizer.\n\n__Note:__ Auto-resize is only available on columns that have the `autoResizable` option set to `true`."
-        },
-        "onFilter": {
-          "type": {
-            "name": "(e: OnFilterParam) => void"
-          },
-          "required": false,
-          "description": "Fired when a filter is applied to a column."
-        },
-        "NoDataComponent": {
-          "type": {
-            "name": "ComponentType<{ noDataText: string; className: string; noDataReason: AnalyticalTableNoDataReason | \"Empty\" | \"Filtered\"; accessibleRole: \"gridcell\"; }>"
-          },
-          "required": false,
-          "description": "Component that will be rendered when the table is not loading and has no data.\n\n__Note:__\n- Although this prop accepts all React components, it is strongly recommended that you use `IllustratedMessage` with `design=\"Auto\"` to preserve the intended design.\n- For `visibleRowCountMode`s \"Auto\" and \"AutoWithEmptyRows\", the `NoDataComponent` spreads to the available space below the header row, otherwise the `minRows` prop defines the minimum height of the table body.\n- To prevent overflow, ensure the table body is at least **60 px** tall when displaying an `IllustratedMessage`.",
-          "defaultValue": {
-            "value": "DefaultNoDataComponent"
-          }
-        },
-        "tableInstance": {
-          "type": {
-            "name": "Ref<TableInstance>"
-          },
-          "required": false,
-          "description": "Exposes the internal table instance.\nThis object will contain all [instance properties (react-table v7)](https://github.com/TanStack/table/blob/v7/docs/src/pages/docs/api/useTable.md#instance-properties)\nof the `useTable` hook and all instance properties from `useColumnOrder`, `useExpanded`, `useFilters`,\n`useGlobalFilter`, `useGroupBy`,`useResizeColumns`, `useRowSelect` and `useSortBy` plugin hooks.\n\n**Note**: Use this prop with care, some properties might have an impact on the internal `AnalyticalTable` implementation."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<AnalyticalTableDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "FilterBar": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `FilterBar` displays filters in a user-friendly manner to populate values for a query. It consists of a row containing the `VariantManagement` or a title, the related buttons, and an area underneath displaying the filters. The filters are arranged in a logical row that is divided depending on the space available and the width of the filters. The area containing the filters can be hidden or shown using the \"Hide FilterBar / Show FilterBar\" button, the \"Filters\" button shows the filter dialog.\nIn this dialog, the consumer has full control over the FilterBar. The filters in this dialog are displayed in one column and organized in groups. Each filter can be marked as visible in the FilterBar by selecting the respective row.\n\n__Responsiveness:__\nThe name of the view or title is always visible. The filter area varies:\n\n* Desktop: Expanded or collapsed by default\n* Tablet: Collapsed by default\n* Phone: Not displayed. Accessible through filter dialog.\n\n__Note:__ When `hideToolbar` is set to `true`, filters are always visible.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": true,
-          "description": "Defines the filters of the `FilterBar`.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `FilterGroupItems` in order to preserve the intended design."
-        },
-        "search": {
-          "type": {
-            "name": "ReactElement<InputPropTypes, string | JSXElementConstructor<any>>"
-          },
-          "required": false,
-          "description": "Defines the search field rendered as first filter item.\n\n__Note:__ By default, `placeholder`, `icon`, `noTypeahead`, `showClearIcon`, and `type` are applied to the search input. Only `placeholder` and `noTypeahead` can be overridden.\n\n__Note:__ The field is only available in the FilterBar not inside the filter configuration dialog."
-        },
-        "header": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "Specifies header text or variant management that is shown in the toolbar on the first position\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `VariantManagement`, `Text` or `Title` in order to preserve the intended design.\n\n__Note:__ If `hideToolbar` is `true` this prop has no effect."
-        },
-        "hideToolbar": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the toolbar on top of the filter items is displayed.\n\n__Note:__ If set to `true`, `header` and the \"Hide/Show FilterBar\" button are not available, the `filterBarCollapsed` prop has no effect and the rest of the buttons are moved to the bottom right side of the filter area."
-        },
-        "filterBarCollapsed": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the `FilterBar` is collapsed.\n\n__Note:__ This prop has no effect if `hideToolbar` is `true`."
-        },
-        "filterContainerWidth": {
-          "type": {
-            "name": "Width<string | number>"
-          },
-          "required": false,
-          "description": "Defines the width of the `FilterGroupItems`.\n\n__Note:__ If your filter elements have an internal `minWidth`, please make sure to overwrite it with `minWidth:'auto'` or the corresponding `filterContainerWidth` otherwise it can lead to unintended behavior."
-        },
-        "considerGroupName": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the `groupName` of the `FilterGroupItems` is displayed."
-        },
-        "showClearOnFB": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the \"Clear\" button is displayed in the `FilterBar`."
-        },
-        "showGoOnFB": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the \"Go\" button is displayed in the `FilterBar`."
-        },
-        "hideFilterConfiguration": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the \"Filter\" button is displayed in the `FilterBar`.\n\n__Note:__ Clicking on the button will open the filter configuration dialog, where you can add/remove filters to the `FilterBar`."
-        },
-        "showResetButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the \"Reset\" button is displayed in the filter configuration dialog."
-        },
-        "hideToggleFiltersButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the \"Hide/Show Filters\" button is displayed in the `FilterBar`.\n\n__Note:__ If `hideToolbar` is `true` or the FilterBar is used on mobile, this prop has no effect."
-        },
-        "activeFiltersCount": {
-          "type": {
-            "name": "string | number"
-          },
-          "required": false,
-          "description": "Defines the number of active filters displayed in the \"Filter\" button.\n\n__Note__: If `hideFilterConfiguration` is `true` this prop has no effect."
-        },
-        "showRestoreOnFB": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the \"Restore\" button is displayed in the `FilterBar`."
-        },
-        "enableReordering": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Allow changing the order of filters in the filter configuration dialog."
-        },
-        "as": {
-          "type": {
-            "name": "enum",
-            "raw": "keyof HTMLElementTagNameMap",
-            "value": [
-              {
-                "value": "\"object\""
-              },
-              {
-                "value": "\"slot\""
-              },
-              {
-                "value": "\"style\""
-              },
-              {
-                "value": "\"title\""
-              },
-              {
-                "value": "\"search\""
-              },
-              {
-                "value": "\"header\""
-              },
-              {
-                "value": "\"link\""
-              },
-              {
-                "value": "\"small\""
-              },
-              {
-                "value": "\"sub\""
-              },
-              {
-                "value": "\"sup\""
-              },
-              {
-                "value": "\"map\""
-              },
-              {
-                "value": "\"a\""
-              },
-              {
-                "value": "\"abbr\""
-              },
-              {
-                "value": "\"address\""
-              },
-              {
-                "value": "\"area\""
-              },
-              {
-                "value": "\"article\""
-              },
-              {
-                "value": "\"aside\""
-              },
-              {
-                "value": "\"audio\""
-              },
-              {
-                "value": "\"b\""
-              },
-              {
-                "value": "\"base\""
-              },
-              {
-                "value": "\"bdi\""
-              },
-              {
-                "value": "\"bdo\""
-              },
-              {
-                "value": "\"blockquote\""
-              },
-              {
-                "value": "\"body\""
-              },
-              {
-                "value": "\"br\""
-              },
-              {
-                "value": "\"button\""
-              },
-              {
-                "value": "\"canvas\""
-              },
-              {
-                "value": "\"caption\""
-              },
-              {
-                "value": "\"cite\""
-              },
-              {
-                "value": "\"code\""
-              },
-              {
-                "value": "\"col\""
-              },
-              {
-                "value": "\"colgroup\""
-              },
-              {
-                "value": "\"data\""
-              },
-              {
-                "value": "\"datalist\""
-              },
-              {
-                "value": "\"dd\""
-              },
-              {
-                "value": "\"del\""
-              },
-              {
-                "value": "\"details\""
-              },
-              {
-                "value": "\"dfn\""
-              },
-              {
-                "value": "\"dialog\""
-              },
-              {
-                "value": "\"div\""
-              },
-              {
-                "value": "\"dl\""
-              },
-              {
-                "value": "\"dt\""
-              },
-              {
-                "value": "\"em\""
-              },
-              {
-                "value": "\"embed\""
-              },
-              {
-                "value": "\"fieldset\""
-              },
-              {
-                "value": "\"figcaption\""
-              },
-              {
-                "value": "\"figure\""
-              },
-              {
-                "value": "\"footer\""
-              },
-              {
-                "value": "\"form\""
-              },
-              {
-                "value": "\"h1\""
-              },
-              {
-                "value": "\"h2\""
-              },
-              {
-                "value": "\"h3\""
-              },
-              {
-                "value": "\"h4\""
-              },
-              {
-                "value": "\"h5\""
-              },
-              {
-                "value": "\"h6\""
-              },
-              {
-                "value": "\"head\""
-              },
-              {
-                "value": "\"hgroup\""
-              },
-              {
-                "value": "\"hr\""
-              },
-              {
-                "value": "\"html\""
-              },
-              {
-                "value": "\"i\""
-              },
-              {
-                "value": "\"iframe\""
-              },
-              {
-                "value": "\"img\""
-              },
-              {
-                "value": "\"input\""
-              },
-              {
-                "value": "\"ins\""
-              },
-              {
-                "value": "\"kbd\""
-              },
-              {
-                "value": "\"label\""
-              },
-              {
-                "value": "\"legend\""
-              },
-              {
-                "value": "\"li\""
-              },
-              {
-                "value": "\"main\""
-              },
-              {
-                "value": "\"mark\""
-              },
-              {
-                "value": "\"menu\""
-              },
-              {
-                "value": "\"meta\""
-              },
-              {
-                "value": "\"meter\""
-              },
-              {
-                "value": "\"nav\""
-              },
-              {
-                "value": "\"noscript\""
-              },
-              {
-                "value": "\"ol\""
-              },
-              {
-                "value": "\"optgroup\""
-              },
-              {
-                "value": "\"option\""
-              },
-              {
-                "value": "\"output\""
-              },
-              {
-                "value": "\"p\""
-              },
-              {
-                "value": "\"picture\""
-              },
-              {
-                "value": "\"pre\""
-              },
-              {
-                "value": "\"progress\""
-              },
-              {
-                "value": "\"q\""
-              },
-              {
-                "value": "\"rp\""
-              },
-              {
-                "value": "\"rt\""
-              },
-              {
-                "value": "\"ruby\""
-              },
-              {
-                "value": "\"s\""
-              },
-              {
-                "value": "\"samp\""
-              },
-              {
-                "value": "\"script\""
-              },
-              {
-                "value": "\"section\""
-              },
-              {
-                "value": "\"select\""
-              },
-              {
-                "value": "\"source\""
-              },
-              {
-                "value": "\"span\""
-              },
-              {
-                "value": "\"strong\""
-              },
-              {
-                "value": "\"summary\""
-              },
-              {
-                "value": "\"table\""
-              },
-              {
-                "value": "\"tbody\""
-              },
-              {
-                "value": "\"td\""
-              },
-              {
-                "value": "\"template\""
-              },
-              {
-                "value": "\"textarea\""
-              },
-              {
-                "value": "\"tfoot\""
-              },
-              {
-                "value": "\"th\""
-              },
-              {
-                "value": "\"thead\""
-              },
-              {
-                "value": "\"time\""
-              },
-              {
-                "value": "\"tr\""
-              },
-              {
-                "value": "\"track\""
-              },
-              {
-                "value": "\"u\""
-              },
-              {
-                "value": "\"ul\""
-              },
-              {
-                "value": "\"var\""
-              },
-              {
-                "value": "\"video\""
-              },
-              {
-                "value": "\"wbr\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Sets the components outer HTML tag.\n\n__Note:__ For TypeScript the types of `ref` are bound to the default tag name, if you change it you are responsible to set the respective types yourself."
-        },
-        "onToggleFilters": {
-          "type": {
-            "name": "(event: OnToggleFiltersEvent) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the `FilterBar` is collapsed/expanded."
-        },
-        "onFiltersDialogSave": {
-          "type": {
-            "name": "(event: OnFiltersDialogSaveEvent) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the \"Go\" button of the filter configuration dialog is clicked."
-        },
-        "onFiltersDialogCancel": {
-          "type": {
-            "name": "(escPressed: boolean) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the \"Cancel\" button of the filter configuration dialog is clicked or when the dialog is closed by pressing the \"Escape\" key."
-        },
-        "onFiltersDialogOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ToolbarButtonDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the filter configuration dialog is opened.\n\n__Note:__ By adding `event.preventDefault()` to the function body, opening the dialog is prevented and you can add your own custom component. Even though this is possible, we highly recommend using the default dialog in order to preserve the intended design."
-        },
-        "onAfterFiltersDialogOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "The event is fired after the filter configuration dialog has been opened."
-        },
-        "onFiltersDialogClose": {
-          "type": {
-            "name": "(closeTrigger: \"cancelButtonPressed\" | \"okButtonPressed\" | \"escPressed\") => void"
-          },
-          "required": false,
-          "description": "The event is fired when the filter configuration dialog is closed."
-        },
-        "onReorder": {
-          "type": {
-            "name": "(payload: { reorderedFilterKeys: string[]; }) => void"
-          },
-          "required": false,
-          "description": "The event is fired when a filter is reordered.\n\n__Note:__ The event is only fired if `enableReordering` is `true`."
-        },
-        "onFiltersDialogSelectionChange": {
-          "type": {
-            "name": "(payload: FiltersDialogSelectionChangePayload) => void"
-          },
-          "required": false,
-          "description": "The event is fired when a filter is selected/unselected in the filter configuration dialog."
-        },
-        "onFiltersDialogSearch": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "The event is fired on input in the filter configuration dialog search field."
-        },
-        "onClear": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ToolbarButtonDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the \"Clear\" button is clicked."
-        },
-        "onGo": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ToolbarButtonDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the \"Go\" button is clicked."
-        },
-        "onRestore": {
-          "type": {
-            "name": "(payload: RestorePayload) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the \"Reset\" button in the filter dialog is pressed, or the \"Restore\" button in the FilterBar."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "FilterGroupItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Represents a filter belonging to the `FilterBar`.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "filterKey": {
-          "type": {
-            "name": "string | number"
-          },
-          "required": true,
-          "description": "The mandatory key each `FilterGroupItem` needs to implement.\n\n__Note:__\n- `filterKey` needs to be unique for each `FilterGroupItem` per `FilterBar`.\n- Whitespace characters are not supported."
-        },
-        "children": {
-          "type": {
-            "name": "ReactElement<unknown, string | JSXElementConstructor<any>>"
-          },
-          "required": true,
-          "description": "Content of the `FilterGroupItem`.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use form elements like `Input`, `Select` or `Switch` in order to preserve the intended design."
-        },
-        "label": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the label of the `FilterGroupItem`.\n\n__Note:__ This label is used for the search in the filter configuration dialog.",
-          "defaultValue": {
-            "value": "\"\""
-          }
-        },
-        "groupName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the group name of the filter.",
-          "defaultValue": {
-            "value": "\"Basic\""
-          }
-        },
-        "labelTooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the label.\n\n__Note:__ If no `labelTooltip` is set, it uses the `label` text as tooltip."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether a loading indicator should be shown in the `FilterGroupItem`."
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the filter is required.\n\n__Note:__\n- Required filters cannot be removed from the `FilterBar`.\n- If `required` is set to `true`, the corresponding input component should also receive the `required` prop explicitly."
-        },
-        "hidden": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the filter is hidden."
-        },
-        "hiddenInFilterBar": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the filter is hidden in the `FilterBar` or only in the filter configuration dialog."
-        },
-        "considerGroupName": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the `groupName` of the `FilterGroupItems` is displayed in the filter configuration dialog."
-        },
-        "active": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the filter is displayed with a value. If it's active an indicator will be shown in the filter configuration dialog."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "FlexBox": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `FlexBox` builds the container for a flexible box layout by leveraging the CSS flexbox layout.\n\n__Note:__ Since `FlexBox` is purely a layout component, it does not have any associated global design specifications.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "alignItems": {
-          "type": {
-            "name": "enum",
-            "raw": "FlexBoxAlignItems | \"Start\" | \"Center\" | \"End\" | \"Baseline\" | \"Stretch\"",
-            "value": [
-              {
-                "value": "\"Start\"",
-                "description": "Items are aligned toward the start of the flex-direction.<br />\n<b>Note:</b> Corresponds to `flex-start`."
-              },
-              {
-                "value": "\"Center\"",
-                "description": "Items are centered.<br />\n<b>Note:</b> Corresponds to `center`."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Items are aligned toward the end of the flex-direction.<br />\n<b>Note:</b> Corresponds to `flex-end`."
-              },
-              {
-                "value": "\"Baseline\"",
-                "description": "Items are aligned by their baseline.<br />\n<b>Note:</b> Corresponds to `baseline`."
-              },
-              {
-                "value": "\"Stretch\"",
-                "description": "Items are stretched to fill the container.<br />\n<b>Note:</b> Corresponds to `stretch`."
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Baseline\""
-              },
-              {
-                "value": "\"Stretch\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Controls the alignment of items on the Cross Axis.\n\n__Note:__ Corresponds to `align-items`."
-        },
-        "direction": {
-          "type": {
-            "name": "enum",
-            "raw": "FlexBoxDirection | \"Column\" | \"ColumnReverse\" | \"Row\" | \"RowReverse\"",
-            "value": [
-              {
-                "value": "\"Column\"",
-                "description": "Items are placed top to bottom.<br />\n<b>Note:</b> Corresponds to `column`."
-              },
-              {
-                "value": "\"ColumnReverse\"",
-                "description": "Items are placed bottom to top.<br />\n<b>Note:</b> Corresponds to `column-reverse`."
-              },
-              {
-                "value": "\"Row\"",
-                "description": "Items are placed left to right in `ltr` and right to left in `rtl`.<br />\n<b>Note:</b> Corresponds to `row`."
-              },
-              {
-                "value": "\"RowReverse\"",
-                "description": "Items are placed right to left in `ltr` and left to right in `rtl`.<br />\n<b>Note:</b> Corresponds to `row-reverse`."
-              },
-              {
-                "value": "\"Column\""
-              },
-              {
-                "value": "\"ColumnReverse\""
-              },
-              {
-                "value": "\"Row\""
-              },
-              {
-                "value": "\"RowReverse\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Controls how the items are placed in the `FlexBox`.\n\n__Note:__ Corresponds to `flex-direction`."
-        },
-        "displayInline": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the `FlexBox` is in `flex` or `inline-flex` mode."
-        },
-        "fitContainer": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the `FlexBox` will be sized to completely fill its container.\n\n__Note:__ `fitContainer` only works if the height of the containing block is specified (i.e. it doesn't depend on content height)"
-        },
-        "justifyContent": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Start\" | \"Center\" | \"End\" | FlexBoxJustifyContent | \"SpaceAround\" | \"SpaceBetween\"",
-            "value": [
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Start\"",
-                "description": "Items are aligned toward the start of the flex-direction.<br />\n<b>Note:</b> Corresponds to `flex-start`."
-              },
-              {
-                "value": "\"Center\"",
-                "description": "Items are centered.<br />\n<b>Note:</b> Corresponds to `center`."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Items are aligned toward the end of the flex-direction.<br />\n<b>Note:</b> Corresponds to `flex-end`."
-              },
-              {
-                "value": "\"SpaceAround\"",
-                "description": "Items are evenly distributed on the main-axis with equal space around them.<br />\n<b>Note:</b> Corresponds to `space-around`."
-              },
-              {
-                "value": "\"SpaceBetween\"",
-                "description": "Items are evenly distributed on the main-axis; first item is on the start line, last item on the end line.<br />\n<b>Note:</b> Corresponds to `space-between`."
-              },
-              {
-                "value": "\"SpaceAround\""
-              },
-              {
-                "value": "\"SpaceBetween\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines how the browser distributes space between and around items along the main-axis.\n\n__Note:__ Corresponds to `justify-content`."
-        },
-        "wrap": {
-          "type": {
-            "name": "enum",
-            "raw": "FlexBoxWrap | \"NoWrap\" | \"Wrap\" | \"WrapReverse\"",
-            "value": [
-              {
-                "value": "\"NoWrap\"",
-                "description": "All will stay on one line. <br />\n<b>Note:</b> Corresponds to `nowrap`."
-              },
-              {
-                "value": "\"Wrap\"",
-                "description": "Items will wrap onto multiple lines. (top to bottom)<br />\n<b>Note:</b> Corresponds to `wrap`."
-              },
-              {
-                "value": "\"WrapReverse\"",
-                "description": "Items will wrap onto multiple lines. (bottom to top)<br />\n<b>Note:</b> Corresponds to `wrap-reverse`."
-              },
-              {
-                "value": "\"NoWrap\""
-              },
-              {
-                "value": "\"Wrap\""
-              },
-              {
-                "value": "\"WrapReverse\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines whether the `FlexBox` should wrap, when there is not enough space to display all items in one line.\n\n__Note:__ Corresponds to `flex-wrap`."
-        },
-        "gap": {
-          "type": {
-            "name": "Gap<string | number>"
-          },
-          "required": false,
-          "description": "Define the gap (gutters) between flex items and flex lines.\n\n__Note:__ Corresponds to the `gap` CSS Property."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Content of the `FlexBox`."
-        },
-        "as": {
-          "type": {
-            "name": "enum",
-            "raw": "keyof HTMLElementTagNameMap",
-            "value": [
-              {
-                "value": "\"object\""
-              },
-              {
-                "value": "\"slot\""
-              },
-              {
-                "value": "\"style\""
-              },
-              {
-                "value": "\"title\""
-              },
-              {
-                "value": "\"a\""
-              },
-              {
-                "value": "\"abbr\""
-              },
-              {
-                "value": "\"address\""
-              },
-              {
-                "value": "\"area\""
-              },
-              {
-                "value": "\"article\""
-              },
-              {
-                "value": "\"aside\""
-              },
-              {
-                "value": "\"audio\""
-              },
-              {
-                "value": "\"b\""
-              },
-              {
-                "value": "\"base\""
-              },
-              {
-                "value": "\"bdi\""
-              },
-              {
-                "value": "\"bdo\""
-              },
-              {
-                "value": "\"blockquote\""
-              },
-              {
-                "value": "\"body\""
-              },
-              {
-                "value": "\"br\""
-              },
-              {
-                "value": "\"button\""
-              },
-              {
-                "value": "\"canvas\""
-              },
-              {
-                "value": "\"caption\""
-              },
-              {
-                "value": "\"cite\""
-              },
-              {
-                "value": "\"code\""
-              },
-              {
-                "value": "\"col\""
-              },
-              {
-                "value": "\"colgroup\""
-              },
-              {
-                "value": "\"data\""
-              },
-              {
-                "value": "\"datalist\""
-              },
-              {
-                "value": "\"dd\""
-              },
-              {
-                "value": "\"del\""
-              },
-              {
-                "value": "\"details\""
-              },
-              {
-                "value": "\"dfn\""
-              },
-              {
-                "value": "\"dialog\""
-              },
-              {
-                "value": "\"div\""
-              },
-              {
-                "value": "\"dl\""
-              },
-              {
-                "value": "\"dt\""
-              },
-              {
-                "value": "\"em\""
-              },
-              {
-                "value": "\"embed\""
-              },
-              {
-                "value": "\"fieldset\""
-              },
-              {
-                "value": "\"figcaption\""
-              },
-              {
-                "value": "\"figure\""
-              },
-              {
-                "value": "\"footer\""
-              },
-              {
-                "value": "\"form\""
-              },
-              {
-                "value": "\"h1\""
-              },
-              {
-                "value": "\"h2\""
-              },
-              {
-                "value": "\"h3\""
-              },
-              {
-                "value": "\"h4\""
-              },
-              {
-                "value": "\"h5\""
-              },
-              {
-                "value": "\"h6\""
-              },
-              {
-                "value": "\"head\""
-              },
-              {
-                "value": "\"header\""
-              },
-              {
-                "value": "\"hgroup\""
-              },
-              {
-                "value": "\"hr\""
-              },
-              {
-                "value": "\"html\""
-              },
-              {
-                "value": "\"i\""
-              },
-              {
-                "value": "\"iframe\""
-              },
-              {
-                "value": "\"img\""
-              },
-              {
-                "value": "\"input\""
-              },
-              {
-                "value": "\"ins\""
-              },
-              {
-                "value": "\"kbd\""
-              },
-              {
-                "value": "\"label\""
-              },
-              {
-                "value": "\"legend\""
-              },
-              {
-                "value": "\"li\""
-              },
-              {
-                "value": "\"link\""
-              },
-              {
-                "value": "\"main\""
-              },
-              {
-                "value": "\"map\""
-              },
-              {
-                "value": "\"mark\""
-              },
-              {
-                "value": "\"menu\""
-              },
-              {
-                "value": "\"meta\""
-              },
-              {
-                "value": "\"meter\""
-              },
-              {
-                "value": "\"nav\""
-              },
-              {
-                "value": "\"noscript\""
-              },
-              {
-                "value": "\"ol\""
-              },
-              {
-                "value": "\"optgroup\""
-              },
-              {
-                "value": "\"option\""
-              },
-              {
-                "value": "\"output\""
-              },
-              {
-                "value": "\"p\""
-              },
-              {
-                "value": "\"picture\""
-              },
-              {
-                "value": "\"pre\""
-              },
-              {
-                "value": "\"progress\""
-              },
-              {
-                "value": "\"q\""
-              },
-              {
-                "value": "\"rp\""
-              },
-              {
-                "value": "\"rt\""
-              },
-              {
-                "value": "\"ruby\""
-              },
-              {
-                "value": "\"s\""
-              },
-              {
-                "value": "\"samp\""
-              },
-              {
-                "value": "\"script\""
-              },
-              {
-                "value": "\"search\""
-              },
-              {
-                "value": "\"section\""
-              },
-              {
-                "value": "\"select\""
-              },
-              {
-                "value": "\"small\""
-              },
-              {
-                "value": "\"source\""
-              },
-              {
-                "value": "\"span\""
-              },
-              {
-                "value": "\"strong\""
-              },
-              {
-                "value": "\"sub\""
-              },
-              {
-                "value": "\"summary\""
-              },
-              {
-                "value": "\"sup\""
-              },
-              {
-                "value": "\"table\""
-              },
-              {
-                "value": "\"tbody\""
-              },
-              {
-                "value": "\"td\""
-              },
-              {
-                "value": "\"template\""
-              },
-              {
-                "value": "\"textarea\""
-              },
-              {
-                "value": "\"tfoot\""
-              },
-              {
-                "value": "\"th\""
-              },
-              {
-                "value": "\"thead\""
-              },
-              {
-                "value": "\"time\""
-              },
-              {
-                "value": "\"tr\""
-              },
-              {
-                "value": "\"track\""
-              },
-              {
-                "value": "\"u\""
-              },
-              {
-                "value": "\"ul\""
-              },
-              {
-                "value": "\"var\""
-              },
-              {
-                "value": "\"video\""
-              },
-              {
-                "value": "\"wbr\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Sets the components outer HTML tag.\n\n__Note:__ For TypeScript the types of `ref` are bound to the default tag name, if you change it you are responsible to set the respective types yourself."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Grid": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A layout container component used for aligning items with various sizes in a simple grid.\n\n__Note:__ The `Grid` component is only applying grid styles only on the first level of its children. If you want to define a more complex grid, we recommend implementing a standard [CSS grid layout](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_grid_layout).\n\n__Note:__ The `Grid` currently doesn't implement the same wrapping behavior as the `sap.ui.layout.Grid`. To follow UXC guidelines use a different component.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "vSpacing": {
-          "type": {
-            "name": "Height<string | number>"
-          },
-          "required": false,
-          "description": "Vertical spacing between the rows in the Grid. If not specified, then 1rem.",
-          "defaultValue": {
-            "value": "`\"1rem\"`"
-          }
-        },
-        "hSpacing": {
-          "type": {
-            "name": "Width<string | number>"
-          },
-          "required": false,
-          "description": "Horizontal spacing between the content in the Grid. If not specified, then 1rem.",
-          "defaultValue": {
-            "value": "`\"1rem\"`"
-          }
-        },
-        "position": {
-          "type": {
-            "name": "enum",
-            "raw": "GridPosition | \"Left\" | \"Center\" | \"Right\"",
-            "value": [
-              {
-                "value": "\"Left\""
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Right\""
-              },
-              {
-                "value": "\"Left\""
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Right\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Position of the Grid in the window or surrounding container. Possible values are \"Center\", \"Left\" and \"Right\"."
-        },
-        "defaultSpan": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A string type that represents Grid's default span values for very large, large, medium and small screens for the whole Grid.\nAllowed values are separated by space Letters XL, L, M or S followed by number of columns from 1 to 12 that the container has to take, for example: \"L2 M4 S6\", \"M12\", \"s10\" or \"l4 m4\".\nNote that the parameters has to be provided in the order very large, large, medium, small.\n\nYou can override this default span on each child element by setting the prop `data-layout-span`.",
-          "defaultValue": {
-            "value": "`\"XL3 L3 M6 S12\"`"
-          }
-        },
-        "defaultIndent": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines default for the whole Grid numbers of empty columns before the current span begins. It can be defined for very large, large, medium and small screens.\nAllowed values are separated by space Letters XL, L, M or S followed by number of columns from 0 to 12 that the container has to take, for example: \"L2 M4 S6\", \"M11\", \"s10\" or \"l4 m4\".\nNote that the parameters has to be provided in the order very-large, large, medium, small.\n\nYou can override this default indent on each child element by setting the prop `data-layout-indent`.",
-          "defaultValue": {
-            "value": "`\"XL0 L0 M0 S0\"`"
-          }
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Components that are placed into Grid layout."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "MessageBox": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `MessageBox` component provides easier methods to create a `Dialog`, such as standard alerts, confirmation dialogs, or arbitrary message dialogs.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that label the component.\n\n__Note:__ Per default the prop receives the IDs of the header and the content."
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the Message Box should be opened or closed"
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A custom title for the MessageBox. If not present, it will be derived from the `MessageBox` type."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": true,
-          "description": "Defines the content of the `MessageBox`.\n\n**Note:** Although this prop accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design and accessibility capabilities."
-        },
-        "actions": {
-          "type": {
-            "name": "ReactNode[]"
-          },
-          "required": false,
-          "description": "Array of actions of the MessageBox. Those actions will be transformed into buttons in the `MessageBox` footer.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `MessageBoxAction`s (text) or the `Button` component in order to preserve the intended."
-        },
-        "emphasizedAction": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Specifies which action of the created dialog will be emphasized.\n@since 0.16.3",
-          "defaultValue": {
-            "value": "`\"OK\"`"
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "A custom icon. If not present, it will be derived from the `MessageBox` type."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "MessageBoxType | \"Confirm\" | \"Error\" | \"Information\" | \"Success\" | \"Warning\"",
-            "value": [
-              {
-                "value": "\"Confirm\""
-              },
-              {
-                "value": "\"Error\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Success\""
-              },
-              {
-                "value": "\"Warning\""
-              },
-              {
-                "value": "\"Confirm\""
-              },
-              {
-                "value": "\"Error\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Success\""
-              },
-              {
-                "value": "\"Warning\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the type of the `MessageBox` with predefined title, icon, actions and a visual highlight color.",
-          "defaultValue": {
-            "value": "`\"Confirm\"`"
-          }
-        },
-        "initialFocus": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the ID of the HTML Element or the `MessageBoxAction`, which will get the initial focus."
-        },
-        "onClose": {
-          "type": {
-            "name": "(action: string, escPressed?: true) => void"
-          },
-          "required": false,
-          "description": "Callback to be executed when the `MessageBox` is closed (either by pressing on one of the `actions` or by pressing the Escape key).\n`action` is the pressed action button, it's `undefined` when closed via ESC."
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "PopupAccessibleRole | \"None\" | \"Dialog\" | \"AlertDialog\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "Represents no ARIA role."
-              },
-              {
-                "value": "\"Dialog\"",
-                "description": "Represents the ARIA role \"dialog\"."
-              },
-              {
-                "value": "\"AlertDialog\"",
-                "description": "Represents the ARIA role \"alertdialog\"."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Dialog\""
-              },
-              {
-                "value": "\"AlertDialog\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Dialog\""
-          }
-        },
-        "draggable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is draggable.\nIf this property is set to true, the Dialog will be draggable by its header.\n\n**Note:** The component can be draggable only in desktop mode.\n\n**Note:** This property overrides the default HTML \"draggable\" attribute native behavior.\nWhen \"draggable\" is set to true, the native browser \"draggable\"\nbehavior is prevented and only the Dialog custom logic (\"draggable by its header\") works.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "preventFocusRestore": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "preventInitialFocus": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "resizable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Configures the component to be resizable.\nIf this property is set to true, the Dialog will have a resize handle in its bottom right corner in LTR languages.\nIn RTL languages, the resize handle will be placed in the bottom left corner.\n\n**Note:** The component can be resizable only in desktop mode.\n\n**Note:** Upon resizing, externally defined height and width styling will be ignored.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "stretch": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines if the dialog will be stretched to full screen on mobile. On desktop,\nthe dialog will be stretched to approximately 90% of the viewport.\n\n**Note:** For better usability of the component it is recommended to set this property to \"true\" when the dialog is opened on phone.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header HTML Element.\n\n**Note:** When a `Bar` is used in the header, you should remove the default dialog's paddings.\n\n**Note:** If `header` slot is provided, the labelling of the dialog is a responsibility of the application developer.\n`accessibleName` should be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onBeforeClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
-        },
-        "onBeforeOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<DialogDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "MessageItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A component used to hold different types of system messages inside the `MessageView` component.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "titleText": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": true,
-          "description": "Specifies the title of the message\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use text or `Link` (with `wrappingType=\"None\"`) in order to preserve the intended design."
-        },
-        "subtitleText": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "Specifies the subtitle of the message\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design."
-        },
-        "counter": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the number of messages for a given message type."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Specifies the type of the message"
-        },
-        "groupName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Name of a message group the current item belongs to."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Specifies detailed description of the message"
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text alternative of the component.\n\n**Note**: If not provided a default text alternative will be set, if present."
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ListItemCustomDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "MessageView": {
-      "package": "@ui5/webcomponents-react",
-      "description": "\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "length": {
-          "type": {
-            "name": "number"
-          },
-          "required": true,
-          "description": "Gets or sets the length of the array. This is a number one higher than the highest index in the array."
-        },
-        "toString": {
-          "type": {
-            "name": "() => string"
-          },
-          "required": false,
-          "description": "Returns a string representation of an array.",
-          "defaultValue": {}
-        },
-        "toLocaleString": {
-          "type": {
-            "name": "{ (): string; (locales: string | string[], options?: NumberFormatOptions & DateTimeFormatOptions): string; }"
-          },
-          "required": false,
-          "description": "Returns a string representation of an array. The elements are converted to string using their toLocaleString methods.",
-          "defaultValue": {}
-        },
-        "pop": {
-          "type": {
-            "name": "() => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>"
-          },
-          "required": true,
-          "description": "Removes the last element from an array and returns it.\nIf the array is empty, undefined is returned and the array is not modified."
-        },
-        "push": {
-          "type": {
-            "name": "(...items: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]) => number"
-          },
-          "required": true,
-          "description": "Appends new elements to the end of an array, and returns the new length of the array.\n@param items New elements to add to the array."
-        },
-        "concat": {
-          "type": {
-            "name": "{ (...items: ConcatArray<ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>[]): ReactElement<...>[]; (...items: (ReactElement<...> | ConcatArray<...>)[]): ReactElement<...>[]; }"
-          },
-          "required": true,
-          "description": "Combines two or more arrays.\nThis method returns a new array without modifying any existing arrays.\n@param items Additional arrays and/or items to add to the end of the array.\n@param items Additional arrays and/or items to add to the end of the array."
-        },
-        "join": {
-          "type": {
-            "name": "(separator?: string) => string"
-          },
-          "required": true,
-          "description": "Adds all the elements of an array into a string, separated by the specified separator string.\n@param separator A string used to separate one element of the array from the next in the resulting string. If omitted, the array elements are separated with a comma."
-        },
-        "reverse": {
-          "type": {
-            "name": "() => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]"
-          },
-          "required": true,
-          "description": "Reverses the elements in an array in place.\nThis method mutates the array and returns a reference to the same array."
-        },
-        "shift": {
-          "type": {
-            "name": "() => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>"
-          },
-          "required": true,
-          "description": "Removes the first element from an array and returns it.\nIf the array is empty, undefined is returned and the array is not modified."
-        },
-        "slice": {
-          "type": {
-            "name": "(start?: number, end?: number) => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]"
-          },
-          "required": true,
-          "description": "Returns a copy of a section of an array.\nFor both start and end, a negative index can be used to indicate an offset from the end of the array.\nFor example, -2 refers to the second to last element of the array.\n@param start The beginning index of the specified portion of the array.\nIf start is undefined, then the slice begins at index 0.\n@param end The end index of the specified portion of the array. This is exclusive of the element at the index 'end'.\nIf end is undefined, then the slice extends to the end of the array."
-        },
-        "sort": {
-          "type": {
-            "name": "(compareFn?: (a: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, b: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>) => number) => ReactElement<...>[]"
-          },
-          "required": true,
-          "description": "Sorts an array in place.\nThis method mutates the array and returns a reference to the same array.\n@param compareFn Function used to determine the order of the elements. It is expected to return\na negative value if the first argument is less than the second argument, zero if they're equal, and a positive\nvalue otherwise. If omitted, the elements are sorted in ascending, ASCII character order.\n```ts\n[11,2,22,1].sort((a, b) => a - b)\n```"
-        },
-        "splice": {
-          "type": {
-            "name": "{ (start: number, deleteCount?: number): ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]; (start: number, deleteCount: number, ...items: ReactElement<...>[]): ReactElement<...>[]; }"
-          },
-          "required": true,
-          "description": "Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.\n@param start The zero-based location in the array from which to start removing elements.\n@param deleteCount The number of elements to remove.\n@returns An array containing the elements that were deleted.\n@param start The zero-based location in the array from which to start removing elements.\n@param deleteCount The number of elements to remove.\n@param items Elements to insert into the array in place of the deleted elements.\n@returns An array containing the elements that were deleted."
-        },
-        "unshift": {
-          "type": {
-            "name": "(...items: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]) => number"
-          },
-          "required": true,
-          "description": "Inserts new elements at the start of an array, and returns the new length of the array.\n@param items Elements to insert at the start of the array."
-        },
-        "indexOf": {
-          "type": {
-            "name": "(searchElement: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, fromIndex?: number) => number"
-          },
-          "required": true,
-          "description": "Returns the index of the first occurrence of a value in an array, or -1 if it is not present.\n@param searchElement The value to locate in the array.\n@param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0."
-        },
-        "lastIndexOf": {
-          "type": {
-            "name": "(searchElement: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, fromIndex?: number) => number"
-          },
-          "required": true,
-          "description": "Returns the index of the last occurrence of a specified value in an array, or -1 if it is not present.\n@param searchElement The value to locate in the array.\n@param fromIndex The array index at which to begin searching backward. If fromIndex is omitted, the search starts at the last index in the array."
-        },
-        "every": {
-          "type": {
-            "name": "{ <S extends ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, index: number, array: ReactElement<...>[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: ReactElement<...>, index: number..."
-          },
-          "required": true,
-          "description": "Determines whether all the members of an array satisfy the specified test.\n@param predicate A function that accepts up to three arguments. The every method calls\nthe predicate function for each element in the array until the predicate returns a value\nwhich is coercible to the Boolean value false, or until the end of the array.\n@param thisArg An object to which the this keyword can refer in the predicate function.\nIf thisArg is omitted, undefined is used as the this value.\n@param predicate A function that accepts up to three arguments. The every method calls\nthe predicate function for each element in the array until the predicate returns a value\nwhich is coercible to the Boolean value false, or until the end of the array.\n@param thisArg An object to which the this keyword can refer in the predicate function.\nIf thisArg is omitted, undefined is used as the this value."
-        },
-        "some": {
-          "type": {
-            "name": "(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, array: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]) => unknown, thisArg?: any) => boolean"
-          },
-          "required": true,
-          "description": "Determines whether the specified callback function returns true for any element of an array.\n@param predicate A function that accepts up to three arguments. The some method calls\nthe predicate function for each element in the array until the predicate returns a value\nwhich is coercible to the Boolean value true, or until the end of the array.\n@param thisArg An object to which the this keyword can refer in the predicate function.\nIf thisArg is omitted, undefined is used as the this value."
-        },
-        "forEach": {
-          "type": {
-            "name": "(callbackfn: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, array: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]) => void, thisArg?: any) => void"
-          },
-          "required": true,
-          "description": "Performs the specified action for each element in an array.\n@param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.\n@param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value."
-        },
-        "map": {
-          "type": {
-            "name": "<U>(callbackfn: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, array: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]) => U, thisArg?: any) => U[]"
-          },
-          "required": true,
-          "description": "Calls a defined callback function on each element of an array, and returns an array that contains the results.\n@param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.\n@param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value."
-        },
-        "filter": {
-          "type": {
-            "name": "{ <S extends ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, index: number, array: ReactElement<...>[]) => value is S, thisArg?: any): S[]; (predicate: (value: ReactElement<...>, index: number, array:..."
-          },
-          "required": true,
-          "description": "Returns the elements of an array that meet the condition specified in a callback function.\n@param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.\n@param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value.\n@param predicate A function that accepts up to three arguments. The filter method calls the predicate function one time for each element in the array.\n@param thisArg An object to which the this keyword can refer in the predicate function. If thisArg is omitted, undefined is used as the this value."
-        },
-        "reduce": {
-          "type": {
-            "name": "{ (callbackfn: (previousValue: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, currentValue: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, currentIndex: number, array: ReactElement<...>[]) => ReactElement<...>): ReactElement<...>; (callbackfn: (previousValue: React..."
-          },
-          "required": true,
-          "description": "Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.\n@param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.\n@param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.\n@param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.\n@param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value."
-        },
-        "reduceRight": {
-          "type": {
-            "name": "{ (callbackfn: (previousValue: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, currentValue: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, currentIndex: number, array: ReactElement<...>[]) => ReactElement<...>): ReactElement<...>; (callbackfn: (previousValue: React..."
-          },
-          "required": true,
-          "description": "Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.\n@param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.\n@param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.\n@param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.\n@param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value."
-        },
-        "find": {
-          "type": {
-            "name": "{ <S extends ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, index: number, obj: ReactElement<...>[]) => value is S, thisArg?: any): S; (predicate: (value: ReactElement<...>, index: number, obj: React..."
-          },
-          "required": true,
-          "description": "Returns the value of the first element in the array where predicate is true, and undefined\notherwise.\n@param predicate find calls predicate once for each element of the array, in ascending\norder, until it finds one where predicate returns true. If such an element is found, find\nimmediately returns that element value. Otherwise, find returns undefined.\n@param thisArg If provided, it will be used as the this value for each invocation of\npredicate. If it is not provided, undefined is used instead."
-        },
-        "findIndex": {
-          "type": {
-            "name": "(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, obj: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]) => unknown, thisArg?: any) => number"
-          },
-          "required": true,
-          "description": "Returns the index of the first element in the array where predicate is true, and -1\notherwise.\n@param predicate find calls predicate once for each element of the array, in ascending\norder, until it finds one where predicate returns true. If such an element is found,\nfindIndex immediately returns that element index. Otherwise, findIndex returns -1.\n@param thisArg If provided, it will be used as the this value for each invocation of\npredicate. If it is not provided, undefined is used instead."
-        },
-        "fill": {
-          "type": {
-            "name": "(value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, start?: number, end?: number) => ReactElement<...>[]"
-          },
-          "required": true,
-          "description": "Changes all array elements from `start` to `end` index to a static `value` and returns the modified array\n@param value value to fill array section with\n@param start index to start filling the array at. If start is negative, it is treated as\nlength+start where length is the length of the array.\n@param end index to stop filling the array at. If end is negative, it is treated as\nlength+end."
-        },
-        "copyWithin": {
-          "type": {
-            "name": "(target: number, start: number, end?: number) => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]"
-          },
-          "required": true,
-          "description": "Returns the this object after copying a section of the array identified by start and end\nto the same array starting at position target\n@param target If target is negative, it is treated as length+target where length is the\nlength of the array.\n@param start If start is negative, it is treated as length+start. If end is negative, it\nis treated as length+end.\n@param end If not specified, length of the this object is used as its default value."
-        },
-        "entries": {
-          "type": {
-            "name": "() => ArrayIterator<[number, ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>]>"
-          },
-          "required": true,
-          "description": "Returns an iterable of key, value pairs for every entry in the array"
-        },
-        "keys": {
-          "type": {
-            "name": "() => ArrayIterator<number>"
-          },
-          "required": true,
-          "description": "Returns an iterable of keys in the array"
-        },
-        "values": {
-          "type": {
-            "name": "() => ArrayIterator<ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>"
-          },
-          "required": true,
-          "description": "Returns an iterable of values in the array"
-        },
-        "includes": {
-          "type": {
-            "name": "(searchElement: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, fromIndex?: number) => boolean"
-          },
-          "required": true,
-          "description": "Determines whether an array includes a certain element, returning true or false as appropriate.\n@param searchElement The element to search for.\n@param fromIndex The position in this array at which to begin searching for searchElement."
-        },
-        "flatMap": {
-          "type": {
-            "name": "<U, This = undefined>(callback: (this: This, value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, array: ReactElement<...>[]) => U | readonly U[], thisArg?: This) => U[]"
-          },
-          "required": true,
-          "description": "Calls a defined callback function on each element of an array. Then, flattens the result into\na new array.\nThis is identical to a map followed by flat with depth 1.\n@param callback A function that accepts up to three arguments. The flatMap method calls the\ncallback function one time for each element in the array.\n@param thisArg An object to which the this keyword can refer in the callback function. If\nthisArg is omitted, undefined is used as the this value."
-        },
-        "flat": {
-          "type": {
-            "name": "<A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]"
-          },
-          "required": true,
-          "description": "Returns a new array with all sub-array elements concatenated into it recursively up to the\nspecified depth.\n@param depth The maximum recursion depth"
-        },
-        "at": {
-          "type": {
-            "name": "(index: number) => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>"
-          },
-          "required": true,
-          "description": "Returns the item located at the specified index.\n@param index The zero-based index of the desired code unit. A negative index will count back from the last item."
-        },
-        "findLast": {
-          "type": {
-            "name": "{ <S extends ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>>(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>, index: number, array: ReactElement<...>[]) => value is S, thisArg?: any): S; (predicate: (value: ReactElement<...>, index: number, array: R..."
-          },
-          "required": true,
-          "description": "Returns the value of the last element in the array where predicate is true, and undefined\notherwise.\n@param predicate findLast calls predicate once for each element of the array, in descending\norder, until it finds one where predicate returns true. If such an element is found, findLast\nimmediately returns that element value. Otherwise, findLast returns undefined.\n@param thisArg If provided, it will be used as the this value for each invocation of\npredicate. If it is not provided, undefined is used instead."
-        },
-        "findLastIndex": {
-          "type": {
-            "name": "(predicate: (value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, index: number, array: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]) => unknown, thisArg?: any) => number"
-          },
-          "required": true,
-          "description": "Returns the index of the last element in the array where predicate is true, and -1\notherwise.\n@param predicate findLastIndex calls predicate once for each element of the array, in descending\norder, until it finds one where predicate returns true. If such an element is found,\nfindLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.\n@param thisArg If provided, it will be used as the this value for each invocation of\npredicate. If it is not provided, undefined is used instead."
-        },
-        "toReversed": {
-          "type": {
-            "name": "() => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]"
-          },
-          "required": true,
-          "description": "Returns a copy of an array with its elements reversed."
-        },
-        "toSorted": {
-          "type": {
-            "name": "(compareFn?: (a: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>, b: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>) => number) => ReactElement<...>[]"
-          },
-          "required": true,
-          "description": "Returns a copy of an array with its elements sorted.\n@param compareFn Function used to determine the order of the elements. It is expected to return\na negative value if the first argument is less than the second argument, zero if they're equal, and a positive\nvalue otherwise. If omitted, the elements are sorted in ascending, ASCII character order.\n```ts\n[11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22]\n```"
-        },
-        "toSpliced": {
-          "type": {
-            "name": "{ (start: number, deleteCount: number, ...items: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>[]): ReactElement<...>[]; (start: number, deleteCount?: number): ReactElement<...>[]; }"
-          },
-          "required": true,
-          "description": "Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array.\nCopies an array and removes elements while returning the remaining elements.\n@param start The zero-based location in the array from which to start removing elements.\n@param deleteCount The number of elements to remove.\n@param items Elements to insert into the copied array in place of the deleted elements.\n@returns The copied array.\n@param start The zero-based location in the array from which to start removing elements.\n@param deleteCount The number of elements to remove.\n@returns A copy of the original array with the remaining elements."
-        },
-        "with": {
-          "type": {
-            "name": "(index: number, value: ReactElement<MessageItemPropTypes, string | JSXElementConstructor<any>>) => ReactElement<MessageItemPropTypes, string | JSXElementConstructor<...>>[]"
-          },
-          "required": true,
-          "description": "Copies an array, then overwrites the value at the provided index with the\ngiven value. If the index is negative, then it replaces from the end\nof the array.\n@param index The index of the value to overwrite. If the index is\nnegative, then it replaces from the end of the array.\n@param value The value to write into the copied array.\n@returns The copied array with the updated value."
-        }
-      },
-      "methods": []
-    },
-    "MessageViewButton": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `MessageViewButton` can be used for opening a `Popover` containing the `MessageView` component. It should always reflect the message `type` with the highest severity.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Specifies the type of the button.\n\n__Note:__ `\"None\"` is displayed as `\"Information\"`.",
-          "defaultValue": {
-            "value": "\"Negative\""
-          }
-        },
-        "counter": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the number of messages for a given message type.\n\n__Note:__ Numbers smaller than 1 are not displayed."
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ButtonAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls, is currently expanded or collapsed.\nAccepts the following string values: `true` or `false`\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n- **ariaLabel**: Defines the accessible ARIA name of the component.\nAccepts any string value.\n\n - **ariaKeyShortcuts**: Defines keyboard shortcuts that activate or give focus to the button.\n\n- **controls**: Identifies the element (or elements) whose contents or presence are controlled by the button element.\nAccepts a lowercase string value.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "ButtonAccessibleRole | \"Button\" | \"Link\"",
-            "value": [
-              {
-                "value": "\"Button\"",
-                "description": "Represents Default (button) ARIA role."
-              },
-              {
-                "value": "\"Link\"",
-                "description": "Represents the ARIA role \"link\"."
-              },
-              {
-                "value": "\"Button\""
-              },
-              {
-                "value": "\"Link\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Describes the accessibility role of the button.\n\n**Note:** Use <code>ButtonAccessibleRole.Link</code> role only with a press handler, which performs a navigation. In all other scenarios the default button semantics are recommended.\n\n**Note:** Available since [v1.23](https://github.com/UI5/webcomponents/releases/tag/v1.23) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Button\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "endIcon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon, displayed as graphical element within the component after the button text.\n\n**Note:** It is highly recommended to use `endIcon` property only together with `icon` and/or `text` properties.\nUsage of `endIcon` only should be avoided.\n\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the button shows a loading indicator.\n\n**Note:** If set to `true`, a busy indicator component will be displayed on the related button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Specifies the delay in milliseconds before the loading indicator appears within the associated button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\n**Note:** A tooltip attribute should be provided for icon-only buttons, in order to represent their exact meaning/function.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
-        },
-        "badge": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Adds a badge to the button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"badge\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<ButtonBadge>`"
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is activated either with a mouse/tap or by using the Enter or Space key.\n\n**Note:** The event will not be fired if the `disabled` property is set to `true`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|"
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ButtonDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Modals": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Utility class for opening modals in an imperative way.\n\nThese static helper methods might be useful for showing e.g. Toasts or MessageBoxes after successful or failed\nnetwork calls.\n\n**In order to use these helpers, please make sure to render the `Modals` component somewhere in your application tree.**\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {},
-      "methods": []
-    },
-    "NumericSideIndicator": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Holds a set of side indicator attributes used in the AnalyticalCardHeader component.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "number": {
-          "type": {
-            "name": "string | number"
-          },
-          "required": true,
-          "description": "The numeric value"
-        },
-        "state": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueColor",
-            "value": [
-              {
-                "value": "\"Critical\"",
-                "description": "Critical value color."
-              },
-              {
-                "value": "\"Error\"",
-                "description": "Error value color."
-              },
-              {
-                "value": "\"Good\"",
-                "description": "Good value color."
-              },
-              {
-                "value": "\"Neutral\"",
-                "description": "Neutral value color."
-              },
-              {
-                "value": "\"None\"",
-                "description": "None value color.\n\n__Note__: \"None\" has the same color as \"Neutral\" but doesn't add the tooltip and accessible-name for the numeric content."
-              }
-            ]
-          },
-          "required": false,
-          "description": "The semantic color which represents the state of the side indicator.",
-          "defaultValue": {
-            "value": "`\"None\"`"
-          }
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": true,
-          "description": "The title of the indicator"
-        },
-        "unit": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the unit of measurement (scaling prefix) for the numeric value"
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ObjectPage": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A component that allows apps to easily display information related to a business object.\n\nThe `ObjectPage` is composed of a header (title and content) and block content wrapped in sections and subsections that structure the information.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "titleArea": {
-          "type": {
-            "name": "ReactElement<ObjectPageTitlePropTypes, string | JSXElementConstructor<any>>"
-          },
-          "required": false,
-          "description": "Defines the upper, always static, title section of the `ObjectPage`.\n\n__Note:__\n- Use the `ObjectPageTitle` component in order to preserve the intended design.\n- When the `ObjectPageTitle` is rendered inside a custom component, it's essential to pass through all props, as otherwise the component won't function as intended!"
-        },
-        "headerArea": {
-          "type": {
-            "name": "ReactElement<ObjectPageHeaderPropTypes, string | JSXElementConstructor<any>>"
-          },
-          "required": false,
-          "description": "Defines the `ObjectPageHeader` section of the `ObjectPage`.\n\n__Note:__\n- Use the `ObjectPageHeader` component in order to preserve the intended design.\n- The `ObjectPageHeader` is essentially the `DynamicPageHeader` recommended by SAP Design. It was renamed in v2 to avoid conflicts with the `DynamicPageHeader` from `@ui5/webcomponents`.\n- When the `ObjectPageHeader` is rendered inside a custom component, it's essential to pass through all props, as otherwise the component won't function as intended!"
-        },
-        "footerArea": {
-          "type": {
-            "name": "ReactElement<unknown, string | JSXElementConstructor<any>>"
-          },
-          "required": false,
-          "description": "React element which defines the footer content.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `Bar` with `design={BarDesign.FloatingFooter}` in order to preserve the intended design."
-        },
-        "image": {
-          "type": {
-            "name": "string | ReactElement<AvatarPropTypes, string | JSXElementConstructor<any>>"
-          },
-          "required": false,
-          "description": "Defines the image of the `ObjectPage`. You can pass a path to an image or an `Avatar` component."
-        },
-        "children": {
-          "type": {
-            "name": "ObjectPageSectionType | ObjectPageSectionType[]"
-          },
-          "required": false,
-          "description": "Defines the content area of the `ObjectPage`. It consists of sections and subsections.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `ObjectPageSection` in order to preserve the intended design."
-        },
-        "selectedSectionId": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Sets the current selected `ObjectPageSection` by `id`.\n\n__Note:__ If a valid `selectedSubSectionId` is set, this prop has no effect."
-        },
-        "selectedSubSectionId": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Sets the current selected `ObjectPageSubSection` by `id`."
-        },
-        "headerPinned": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the `headerArea` is pinned."
-        },
-        "imageShapeCircle": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the image should be displayed in a circle or in a square.<br />\n__Note:__ If the `image` is not a `string`, this prop has no effect."
-        },
-        "mode": {
-          "type": {
-            "name": "enum",
-            "raw": "ObjectPageMode | \"Default\" | \"IconTabBar\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "All `ObjectPageSections` and `ObjectPageSubSections` are displayed on one page.\nSelecting tabs will scroll to the corresponding section."
-              },
-              {
-                "value": "\"IconTabBar\"",
-                "description": "All `ObjectPageSections` are displayed on separate pages.\nSelecting tabs will lead to the corresponding page."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"IconTabBar\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the `ObjectPage` mode.\n\n- \"Default\": All `ObjectPageSections` and `ObjectPageSubSections` are displayed on one page. Selecting tabs will scroll to the corresponding section.\n- \"IconTabBar\": All `ObjectPageSections` are displayed on separate pages. Selecting tabs will lead to the corresponding page.",
-          "defaultValue": {
-            "value": "`\"Default\"`"
-          }
-        },
-        "hidePinButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the pin button for the `headerArea` is hidden."
-        },
-        "preserveHeaderStateOnClick": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the user can switch between the expanded/collapsed states of the `ObjectPageHeader` by clicking on the `ObjectPageTitle`.\n\n__Note:__ Per default the header is toggleable."
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "{ objectPageTopHeader?: { role?: string; ariaRoledescription?: string; }; objectPageAnchorBar?: { expandButton?: { expanded?: boolean | \"true\" | \"false\"; accessibleName?: string; }; role?: string; }; objectPageFooterArea?: { ...; }; }"
-          },
-          "required": false,
-          "description": "Defines internally used accessibility properties/attributes."
-        },
-        "placeholder": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "If set, only the specified placeholder will be displayed as content of the `ObjectPage`, no sections or sub-sections will be rendered.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use placeholder components like the `IllustratedMessage` or custom skeletons pages in order to preserve the intended design."
-        },
-        "onBeforeNavigate": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TabContainerDomRef, ObjectPageTabSelectEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a section is selected via the tab bar, before navigation occurs. To cancel navigation, call `event.preventDefault()` within the event handler.\n\n__Note:__ This event is fired every time a user selects a section, even if the section is already selected."
-        },
-        "onSelectedSectionChange": {
-          "type": {
-            "name": "(event: CustomEvent<{ selectedSectionIndex: number; selectedSectionId: string; section: HTMLDivElement; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when the selected section changes."
-        },
-        "onToggleHeaderArea": {
-          "type": {
-            "name": "(visible: boolean) => void"
-          },
-          "required": false,
-          "description": "Fired when the `headerArea` is expanded or collapsed."
-        },
-        "onPinButtonToggle": {
-          "type": {
-            "name": "(pinned: boolean) => void"
-          },
-          "required": false,
-          "description": "Fired when the `headerArea` changes its pinned state."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ObjectPageDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ObjectPageAnchorBar": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ObjectPageAnchorBar` bar contains the expand/collapse (expands or collapses the header content) and pin button (pins the content header).\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "headerContentVisible": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": true,
-          "description": "Determines if the header content is visible."
-        },
-        "hidePinButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": true,
-          "description": "Defines if the pin button is hidden."
-        },
-        "headerPinned": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines if the header is initially pinned ."
-        },
-        "setHeaderPinned": {
-          "type": {
-            "name": "Dispatch<SetStateAction<boolean>>"
-          },
-          "required": false,
-          "description": "Set the header to the state pinned."
-        },
-        "onToggleHeaderContentVisibility": {
-          "type": {
-            "name": "(e: any) => void"
-          },
-          "required": true,
-          "description": "Toggles the header content to be hidden or visible ."
-        },
-        "onHoverToggleButton": {
-          "type": {
-            "name": "(e: MouseEvent<ToggleButtonDomRef, MouseEvent>) => void"
-          },
-          "required": false,
-          "description": "Highlight title when hovered."
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "{ expandButton?: { expanded?: boolean | \"true\" | \"false\"; accessibleName?: string; }; role?: string; }"
-          },
-          "required": false,
-          "description": "Defines internally used accessibility properties/attributes."
-        },
-        "onPinButtonToggle": {
-          "type": {
-            "name": "(pinned: boolean) => void"
-          },
-          "required": false,
-          "description": "Fired when the `headerContent` changes its pinned state."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ObjectPageHeader": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ObjectPageHeader` component is used to serve as header section of the `ObjectPage`. It can hold any layout control and has two states - expanded and collapsed.\n\n__Note:__\n- When used inside a custom component, it's essential to pass through all props, as otherwise the component won't function as intended!\n- The `ObjectPageHeader` is essentially the `DynamicPageHeader` recommended by SAP Design. It was renamed in v2 to avoid conflicts with the `DynamicPageHeader` from `@ui5/webcomponents`.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "headerPinned": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines if the header is pinned."
-        },
-        "topHeaderHeight": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Determines the height of the top header (`ObjectPageTitle`)."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Content of the `ObjectPageHeader`."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ObjectPageSection": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Top-level information container of an `ObjectPage`.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "id": {
-          "type": {
-            "name": "string"
-          },
-          "required": true,
-          "description": "Defines the ID of the `ObjectPageSection`.\n\n__Note:__ The `id` is taken into account when the section selection changes."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": true,
-          "description": "Defines the content of the `ObjectPageSection`.\n\n__Note:__ Only use subsections if more than one is available. Otherwise, add the content of the section directly as `child`."
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": true,
-          "description": "Defines the title of the `ObjectPageSection`."
-        },
-        "titleTextUppercase": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the title is always displayed in uppercase."
-        },
-        "hideTitleText": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether to display the Section title or not."
-        },
-        "titleTextLevel": {
-          "type": {
-            "name": "enum",
-            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
-            "value": [
-              {
-                "value": "\"H1\"",
-                "description": "Renders `h1` tag."
-              },
-              {
-                "value": "\"H2\"",
-                "description": "Renders `h2` tag."
-              },
-              {
-                "value": "\"H3\"",
-                "description": "Renders `h3` tag."
-              },
-              {
-                "value": "\"H4\"",
-                "description": "Renders `h4` tag."
-              },
-              {
-                "value": "\"H5\"",
-                "description": "Renders `h5` tag."
-              },
-              {
-                "value": "\"H6\"",
-                "description": "Renders `h6` tag."
-              },
-              {
-                "value": "\"H1\""
-              },
-              {
-                "value": "\"H2\""
-              },
-              {
-                "value": "\"H3\""
-              },
-              {
-                "value": "\"H4\""
-              },
-              {
-                "value": "\"H5\""
-              },
-              {
-                "value": "\"H6\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the ARIA level of the ObjectPageSection `titleText`. The ARIA level is used by assisting technologies, such as screen readers, to create a hierarchical site map for faster navigation.\n\n__Note:__ Defining a `titleTextLevel` will add aria-level attribute from 1 to 6, instead of changing the ObjectPageSectionBase title HTML tag from H1 to H6.\nFor example: if titleTextLevel is TitleLevel.H1, it will result as aria-level of 1 added to the ObjectPageSection title.",
-          "defaultValue": {
-            "value": "TitleLevel.H3"
-          }
-        },
-        "wrapTitleText": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the Section title wraps on multiple lines, when the available space is not enough."
-        },
-        "header": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "Section header content.\n\n__Note__: Although this prop accepts all HTML Elements, it is strongly recommended that you only use non-focusable elements to preserve the intended design."
-        },
-        "tabRef": {
-          "type": {
-            "name": "Ref<TabDomRef>"
-          },
-          "required": false,
-          "description": "This ref will be attached to the underlying `ui5-tab` DOM element,\nallowing direct access to its instance methods and properties (e.g. `getDomRefInStrip`)."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ObjectPageSubSection": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Second-level information container of an `ObjectPage`.\n\n__Note:__ This component should only be used inside an `ObjectPageSection` component.\n\n__Note:__ Only use subsections if more than one is available. Otherwise, add the content of the section directly as `child` of the `ObjectPageSection`.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "id": {
-          "type": {
-            "name": "string"
-          },
-          "required": true,
-          "description": "Defines the ID of the `ObjectPageSubSection`."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": true,
-          "description": "Defines the content of the `ObjectPageSubSection`."
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": true,
-          "description": "Defines the title of the `ObjectPageSubSection`."
-        },
-        "actions": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Actions available for this subsection.\n\n__Note:__ Keep in mind that the components set in the actions prop do NOT have overflow behavior. If the available space is not enough, the components will be displayed on more lines.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use simple input components like `Button` or `Switch` to preserve the intended design."
-        },
-        "hideTitleText": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether to display the SubSection `titleText` or not."
-        },
-        "titleTextLevel": {
-          "type": {
-            "name": "enum",
-            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
-            "value": [
-              {
-                "value": "\"H1\"",
-                "description": "Renders `h1` tag."
-              },
-              {
-                "value": "\"H2\"",
-                "description": "Renders `h2` tag."
-              },
-              {
-                "value": "\"H3\"",
-                "description": "Renders `h3` tag."
-              },
-              {
-                "value": "\"H4\"",
-                "description": "Renders `h4` tag."
-              },
-              {
-                "value": "\"H5\"",
-                "description": "Renders `h5` tag."
-              },
-              {
-                "value": "\"H6\"",
-                "description": "Renders `h6` tag."
-              },
-              {
-                "value": "\"H1\""
-              },
-              {
-                "value": "\"H2\""
-              },
-              {
-                "value": "\"H3\""
-              },
-              {
-                "value": "\"H4\""
-              },
-              {
-                "value": "\"H5\""
-              },
-              {
-                "value": "\"H6\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the ARIA level of the ObjectPageSubSection `titleText`. The ARIA level is used by assisting technologies, such as screen readers, to create a hierarchical site map for faster navigation.\n\n__Note:__ Defining a `titleTextLevel` will add aria-level attribute from 1 to 6, instead of changing the ObjectPageSectionBase title HTML tag from H1 to H6.\nFor example: if titleTextLevel is TitleLevel.H1, it will result as aria-level of 1 added to the ObjectPageSection title.",
-          "defaultValue": {
-            "value": "TittleLevel.H4"
-          }
-        },
-        "titleTextUppercase": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the title is always displayed in uppercase."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ObjectPageTitle": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ObjectPageTitle` component is used to serve as title of the `ObjectPage`.\nIt can contain Breadcrumbs, Title, Subtitle, Content, KPIs and Actions.\n\n__Note:__ When used inside a custom component, it's essential to pass through all props, as otherwise the component won't function as intended!\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "actionsBar": {
-          "type": {
-            "name": "ReactElement<unknown, string | JSXElementConstructor<any>>"
-          },
-          "required": false,
-          "description": "Defines the actions bar of the `ObjectPageTitle`.\n\n__Note:__ Although this prop accepts all `ReactElement`s, it is strongly recommended that you only use the `Toolbar` component in order to preserve the intended design."
-        },
-        "breadcrumbs": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "The `breadcrumbs` displayed in the `ObjectPageTitle` top-left area.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `Breadcrumbs` in order to preserve the intended design."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "The content is positioned in the `ObjectPageTitle` middle area"
-        },
-        "header": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "The `header` is displayed in the left area of the `ObjectPageTitle`.\nUse this prop to render a `Title` or any other component that serves as a heading.\n\n__Note:__ If the header is snapped (collapsed), the `snappedHeader` prop is used instead (if defined)."
-        },
-        "snappedHeader": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "The `snappedHeader` is displayed in the left area of the `ObjectPageTitle` when the header is snapped (collapsed).\nUse this prop to render a `Title` or any other component that serves as a heading in the snapped view.\n@since 2.12.0"
-        },
-        "subHeader": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "The `subHeader` is displayed in the left area of the `ObjectPageTitle`, below the `header`.\nUse this prop to render a `Label` or any other component that serves as a sub-header.\n\n__Note:__ If the header is snapped (collapsed), the `snappedSubHeader` prop is used instead (if defined)."
-        },
-        "snappedSubHeader": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "The `snappedSubHeader` is displayed in the left area of the `ObjectPageTitle` when the header is snapped (collapsed).\nUse this prop to render a `Label` or any other component that serves as a sub-header in the snapped view.\n@since 2.12.0"
-        },
-        "navigationBar": {
-          "type": {
-            "name": "ReactElement<unknown, string | JSXElementConstructor<any>>"
-          },
-          "required": false,
-          "description": "Defines navigation-actions bar of the `ObjectPageTitle`.\n\n*Note*: The `navigationBar` position depends on the control size.\nIf the control size is 1280px or bigger, they are rendered right next to the `actionsBar`.\nOtherwise, they are rendered in the top-right area (above the `actionsBar`).\nIf a large number of elements(buttons) are used, there could be visual degradations as the space for the `navigationBar` is limited.\n\n__Note:__ Although this prop accepts all `ReactElement`s, it is strongly recommended that you only use the `Toolbar` component in order to preserve the intended design."
-        },
-        "expandedContent": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "The content displayed in the `ObjectPageTitle` in expanded state."
-        },
-        "snappedContent": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "The content displayed in the `ObjectPageTitle` in collapsed (snapped) state."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ObjectStatus": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Status information that can be either text with a value state, or an icon.\n\n__Note:__ When used in interactive lists or tables, consider overriding the active state styling. Learn more [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/data-display-objectstatus--docs#objectstatus-in-interactive-lists-or-tables).\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "interactive": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if the ObjectStatus is rendered as inactive `div` or interactive `button` and therefore can be clicked/tapped by the user or not.\n\n**Note:** If this prop is set to `true`, you should also set the `children` or `icon` prop.\n@since 0.16.6"
-        },
-        "icon": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "Defines the icon in front of the `ObjectStatus` text.\n\n__Note:__ Although this slot accepts HTML Elements, it is strongly recommended that you only use the `Icon` component with `mode=\"Decorative\"` in order to preserve the intended design."
-        },
-        "inverted": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the background color reflects the set state instead of the text\n@since 0.16.6"
-        },
-        "large": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the component should be rendered in large design.\n@since 1.21.0"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode"
-          },
-          "required": false,
-          "description": "Defines the text of the `ObjectStatus`.\n\n__Note:__ Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design."
-        },
-        "state": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\" | IndicationColor | \"Indication01\" | \"Indication02\" | \"Indication03\" | ... 16 more ... | \"Indication20\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Indication01\"",
-                "description": "Dark Red"
-              },
-              {
-                "value": "\"Indication02\"",
-                "description": "Red"
-              },
-              {
-                "value": "\"Indication03\"",
-                "description": "Yellow"
-              },
-              {
-                "value": "\"Indication04\"",
-                "description": "Green"
-              },
-              {
-                "value": "\"Indication05\"",
-                "description": "Blue"
-              },
-              {
-                "value": "\"Indication06\"",
-                "description": "Teal"
-              },
-              {
-                "value": "\"Indication07\"",
-                "description": "Purple"
-              },
-              {
-                "value": "\"Indication08\"",
-                "description": "Pink"
-              },
-              {
-                "value": "\"Indication09\"",
-                "description": "Black/White"
-              },
-              {
-                "value": "\"Indication10\"",
-                "description": "Grey"
-              },
-              {
-                "value": "\"Indication11\"",
-                "description": "Dark Red (second color set)"
-              },
-              {
-                "value": "\"Indication12\"",
-                "description": "Red (second color set)"
-              },
-              {
-                "value": "\"Indication13\"",
-                "description": "Yellow (second color set)"
-              },
-              {
-                "value": "\"Indication14\"",
-                "description": "Green (second color set)"
-              },
-              {
-                "value": "\"Indication15\"",
-                "description": "Blue (second color set)"
-              },
-              {
-                "value": "\"Indication16\"",
-                "description": "Teal (second color set)"
-              },
-              {
-                "value": "\"Indication17\"",
-                "description": "Purple (second color set)"
-              },
-              {
-                "value": "\"Indication18\"",
-                "description": "Pink (second color set)"
-              },
-              {
-                "value": "\"Indication19\"",
-                "description": "Black/White (second color set)"
-              },
-              {
-                "value": "\"Indication20\"",
-                "description": "Grey (second color set)"
-              },
-              {
-                "value": "\"Indication01\""
-              },
-              {
-                "value": "\"Indication02\""
-              },
-              {
-                "value": "\"Indication03\""
-              },
-              {
-                "value": "\"Indication04\""
-              },
-              {
-                "value": "\"Indication05\""
-              },
-              {
-                "value": "\"Indication06\""
-              },
-              {
-                "value": "\"Indication07\""
-              },
-              {
-                "value": "\"Indication08\""
-              },
-              {
-                "value": "\"Indication09\""
-              },
-              {
-                "value": "\"Indication10\""
-              },
-              {
-                "value": "\"Indication11\""
-              },
-              {
-                "value": "\"Indication12\""
-              },
-              {
-                "value": "\"Indication13\""
-              },
-              {
-                "value": "\"Indication14\""
-              },
-              {
-                "value": "\"Indication15\""
-              },
-              {
-                "value": "\"Indication16\""
-              },
-              {
-                "value": "\"Indication17\""
-              },
-              {
-                "value": "\"Indication18\""
-              },
-              {
-                "value": "\"Indication19\""
-              },
-              {
-                "value": "\"Indication20\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the `ObjectStatus`.\n\nSince version 0.17.0 the state property also accepts values from enum `IndicationColor`.\n\n__Note:__ Only the `inverted` `ObjectStatus` supports `IndicationColor`s 11-20. For non-inverted `ObjectStatus`, these colors default to the `\"None\"` `state` color and should __not__ be used.",
-          "defaultValue": {
-            "value": "`\"None\"`"
-          }
-        },
-        "showDefaultIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the default icon for each `ValueState` should be displayed.\n\n__Note:__ If the `icon` prop was set, `showDefaultIcon` has no effect."
-        },
-        "emptyIndicator": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Specifies if an empty indicator should be displayed when there is no text.\n@since 1.19.0"
-        },
-        "stateAnnouncementText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Enables overriding of the default state announcement read by screen readers.\n@since 1.19.0"
-        },
-        "onClick": {
-          "type": {
-            "name": "MouseEventHandler<HTMLButtonElement>"
-          },
-          "required": false,
-          "description": "Fires when the user clicks/taps on an interactive text.\n\n__Note:__ This prop has no effect if `interactive` is not set to `true`.\n@since 0.16.6"
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement | HTMLButtonElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ResponsiveGridLayout": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The Responsive Grid Layout positions UI elements in a multi-column flow layout.\nThey can be configured to display a variable number of columns depending on available screen size.\nWith these controls, it is possible to achieve flexible layouts and line breaks for large, medium,\nand small-sized screens, such as desktop, tablet, and mobile.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "columnsS": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Number of columns to show on small screens (`max-width: 599px`)"
-        },
-        "columnsM": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Number of columns to show on medium screens (`width >= 600px and width <=1023px`)"
-        },
-        "columnsL": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Number of columns to show on large screens (`width >= 1024px and width <=1439px`)"
-        },
-        "columnsXL": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Number of columns to show on extra large screens (`min-width: 1440px`)"
-        },
-        "columnSpanS": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines how many columns a single child should cover on small screens."
-        },
-        "columnSpanM": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines how many columns a single child should cover on medium screens."
-        },
-        "columnSpanL": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines how many columns a single child should cover on large screens."
-        },
-        "columnSpanXL": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines how many columns a single child should cover on extra large."
-        },
-        "columnGap": {
-          "type": {
-            "name": "enum",
-            "raw": "\"0.5rem\" | \"1rem\"",
-            "value": [
-              {
-                "value": "\"0.5rem\""
-              },
-              {
-                "value": "\"1rem\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Gap between two columns of the grid"
-        },
-        "rowGap": {
-          "type": {
-            "name": "enum",
-            "raw": "\"0.5rem\" | \"1rem\"",
-            "value": [
-              {
-                "value": "\"0.5rem\""
-              },
-              {
-                "value": "\"1rem\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Gap between two rows of the grid"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Child elements to be placed inside the grid. In case you want to control the column span of each child independently,\nyou can add an element style using the [gridColumn shorthand](https://developer.mozilla.org/en-US/docs/Web/CSS/grid-column).\n\nExample: If you want one child to span across 4 columns, you can add this element style to the child element:\n`style={{ gridColumn: 'span 4' }}`"
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SelectDialog": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The SelectDialog enables users to filter a comprehensive list via a search field and to select one or more items.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component.\n\n__Note:__ If not set, the dialog uses the `headerText` for its accessible name."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the list items of the component.\n\n__Note:__ Although this prop accepts all HTML Elements and therefore also all list items, it is strongly recommended that you only use `ListItemStandard` in order to preserve the intended design."
-        },
-        "showClearButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "This flag controls whether the Clear button is shown. When set to `true`, it provides a way to clear selections. We recommend enabling the Clear button in cases where a mechanism to delete the selection is required: In single selection mode (default mode) or when `rememberSelections` is set to `true`."
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text."
-        },
-        "headerTextAlignCenter": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Specifies the `headerText` alignment."
-        },
-        "headerTextLevel": {
-          "type": {
-            "name": "enum",
-            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
-            "value": [
-              {
-                "value": "\"H1\"",
-                "description": "Renders `h1` tag."
-              },
-              {
-                "value": "\"H2\"",
-                "description": "Renders `h2` tag."
-              },
-              {
-                "value": "\"H3\"",
-                "description": "Renders `h3` tag."
-              },
-              {
-                "value": "\"H4\"",
-                "description": "Renders `h4` tag."
-              },
-              {
-                "value": "\"H5\"",
-                "description": "Renders `h5` tag."
-              },
-              {
-                "value": "\"H6\"",
-                "description": "Renders `h6` tag."
-              },
-              {
-                "value": "\"H1\""
-              },
-              {
-                "value": "\"H2\""
-              },
-              {
-                "value": "\"H3\""
-              },
-              {
-                "value": "\"H4\""
-              },
-              {
-                "value": "\"H5\""
-              },
-              {
-                "value": "\"H6\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the aria-level of the `headerText`.\nAvailable options are: `\"H1\"` to `\"H6\"`.\nThis property does not influence the style of the `headerText`.",
-          "defaultValue": {
-            "value": "\"H1\""
-          }
-        },
-        "confirmButtonText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Overwrites the default text for the confirmation button."
-        },
-        "rememberSelections": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "This flag controls whether the dialog clears the selection after the confirm event has been fired. If the dialog needs to be opened multiple times in the same context to allow for corrections of previous user inputs, set this flag to `true`.\n\n__Note:__ This won't work if the dialog is unmounted, if you want to unmount the dialog when closed, you need to persist the selection yourself."
-        },
-        "numberOfSelectedItems": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the number of selected list items displayed above the list in `MultiSelect` mode. Programmatically setting the counter is necessary if all previously selected elements are to remain selected during search."
-        },
-        "selectionMode": {
-          "type": {
-            "name": "enum",
-            "raw": "ListSelectionMode | \"None\" | \"Single\" | \"SingleStart\" | \"SingleEnd\" | \"SingleAuto\" | \"Multiple\" | \"Delete\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "Default mode (no selection)."
-              },
-              {
-                "value": "\"Single\"",
-                "description": "Right-positioned single selection mode (only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleStart\"",
-                "description": "Left-positioned single selection mode (only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleEnd\"",
-                "description": "Selected item is highlighted but no selection element is visible\n(only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleAuto\"",
-                "description": "Selected item is highlighted and selection is changed upon arrow navigation\n(only one list item can be selected - this is always the focused item)."
-              },
-              {
-                "value": "\"Multiple\"",
-                "description": "Multi selection mode (more than one list item can be selected)."
-              },
-              {
-                "value": "\"Delete\"",
-                "description": "Delete mode (only one list item can be deleted via provided delete button)"
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Single\""
-              },
-              {
-                "value": "\"SingleStart\""
-              },
-              {
-                "value": "\"SingleEnd\""
-              },
-              {
-                "value": "\"SingleAuto\""
-              },
-              {
-                "value": "\"Multiple\""
-              },
-              {
-                "value": "\"Delete\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the mode of the SelectDialog list.\n\n__Note:__ Although this prop accepts all `ListSelectionMode`s, it is strongly recommended that you only use `Single` or `Multiple` in order to preserve the intended design.",
-          "defaultValue": {
-            "value": "ListSelectionMode.Single"
-          }
-        },
-        "listProps": {
-          "type": {
-            "name": "Omit<ListPropTypes, \"children\" | \"growing\" | \"onLoadMore\" | \"footerText\" | \"selectionMode\">"
-          },
-          "required": false,
-          "description": "Defines props you can pass to the internal `List` component.\n\n__Note:__ `selectionMode`, `children`, `growing`, `onLoadMore` and `footerText` are not supported.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "confirmButtonProps": {
-          "type": {
-            "name": "Omit<ButtonPropTypes, \"onClick\" | \"design\">"
-          },
-          "required": false,
-          "description": "Defines the props of the confirm button.\n\n__Note:__`onClick` and `design` are not supported.\n@since 1.25.0"
-        },
-        "onSearchInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, { value: string; }>) => void"
-          },
-          "required": false,
-          "description": "This event will be fired when the value of the search field is changed by a user - e.g. at each key press"
-        },
-        "onSearch": {
-          "type": {
-            "name": "((event: Ui5CustomEvent<InputDomRef, { value: string; }>) => void) | ((event: Ui5CustomEvent<IconDomRef, { value: string; }>) => void)"
-          },
-          "required": false,
-          "description": "This event will be fired when the search button has been clicked or the ENTER key has been pressed in the search field."
-        },
-        "onSearchReset": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<{ prevValue: string; nativeDetail?: number; }, never>) => void"
-          },
-          "required": false,
-          "description": "This event will be fired when the reset button has been clicked in the search field or when the dialog is closed."
-        },
-        "onClear": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ButtonDomRef, { prevSelectedItems: ListItemStandardDomRef[]; nativeDetail: number; }>) => void"
-          },
-          "required": false,
-          "description": "This event will be fired when the clear button has been clicked."
-        },
-        "onConfirm": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ButtonDomRef | ListDomRef, { selectedItems: ListItemBase[]; }>) => void"
-          },
-          "required": false,
-          "description": "This event will be fired when the dialog is confirmed by selecting an item in single selection mode or by pressing the confirmation button in multi selection mode."
-        },
-        "onCancel": {
-          "type": {
-            "name": "((event: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail>) => void) | ((event: Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) => void)"
-          },
-          "required": false,
-          "description": "This event will be fired when the cancel button is clicked or ESC key is pressed."
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | PopupAccessibleRole | \"Dialog\" | \"AlertDialog\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\"",
-                "description": "Represents no ARIA role."
-              },
-              {
-                "value": "\"Dialog\"",
-                "description": "Represents the ARIA role \"dialog\"."
-              },
-              {
-                "value": "\"AlertDialog\"",
-                "description": "Represents the ARIA role \"alertdialog\"."
-              },
-              {
-                "value": "\"Dialog\""
-              },
-              {
-                "value": "\"AlertDialog\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Dialog\""
-          }
-        },
-        "draggable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is draggable.\nIf this property is set to true, the Dialog will be draggable by its header.\n\n**Note:** The component can be draggable only in desktop mode.\n\n**Note:** This property overrides the default HTML \"draggable\" attribute native behavior.\nWhen \"draggable\" is set to true, the native browser \"draggable\"\nbehavior is prevented and only the Dialog custom logic (\"draggable by its header\") works.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "initialFocus": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the ID of the HTML Element, which will get the initial focus.\n\n**Note:** If an element with `autofocus` attribute is added inside the component,\n`initialFocus` won't take effect."
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if the element is open\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "preventFocusRestore": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "preventInitialFocus": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "resizable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Configures the component to be resizable.\nIf this property is set to true, the Dialog will have a resize handle in its bottom right corner in LTR languages.\nIn RTL languages, the resize handle will be placed in the bottom left corner.\n\n**Note:** The component can be resizable only in desktop mode.\n\n**Note:** Upon resizing, externally defined height and width styling will be ignored.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "stretch": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines if the dialog will be stretched to full screen on mobile. On desktop,\nthe dialog will be stretched to approximately 90% of the viewport.\n\n**Note:** For better usability of the component it is recommended to set this property to \"true\" when the dialog is opened on phone.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "onBeforeClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
-        },
-        "onBeforeOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|"
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "growing": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | ListGrowingMode | \"Button\" | \"Scroll\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Button\"",
-                "description": "Component's \"load-more\" is fired upon pressing a \"More\" button.\nat the bottom."
-              },
-              {
-                "value": "\"Scroll\"",
-                "description": "Component's \"load-more\" is fired upon scroll."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Component's growing is not enabled."
-              },
-              {
-                "value": "\"Button\""
-              },
-              {
-                "value": "\"Scroll\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines whether the component will have growing capability either by pressing a `More` button,\nor via user scroll. In both cases `load-more` event is fired.\n\n**Restrictions:** `growing=\"Scroll\"` is not supported for Internet Explorer,\non IE the component will fallback to `growing=\"Button\"`.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "onLoadMore": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user scrolls to the bottom of the list.\n\n**Note:** The event is fired when the `growing='Scroll'` property is enabled.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|"
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<DialogDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Splitter": {
-      "package": "@ui5/webcomponents-react",
-      "description": "\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "height": {
-          "type": {
-            "name": "string | number"
-          },
-          "required": true,
-          "description": ""
-        },
-        "width": {
-          "type": {
-            "name": "string | number"
-          },
-          "required": true,
-          "description": ""
-        },
-        "vertical": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": true,
-          "description": ""
-        },
-        "onResize": {
-          "type": {
-            "name": "(e: OnResizeParam) => void"
-          },
-          "required": true,
-          "description": ""
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SplitterElement": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `SplitterElement` holds the component of the content area. Allowed size values are of the type css property width or\nheight according to the orientation of the `SplitterLayout`. If `size` isn't passed to the element, the width or\nheight of the content area will be calculated automatically according to the size of the given `SplitterLayout`.\nThe `minSize` defines the minimum width or height of the area and is set to 0 when no minimum size is given, so the\ncontent can be completely collapsed.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "resizable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether a resizer element is displayed.\n\nIf the next `SplitterElement` has the prop `resizable={false}`, no resizer element will be shown after this\n`SplitterElement`. The resizer element is only shown when all siblings of the resizer are resizable.\nDefault value of resizable is `true`."
-        },
-        "size": {
-          "type": {
-            "name": "string | number | (string & {})"
-          },
-          "required": false,
-          "description": "Defines the initial size of the `SplitterElement`.\n\n__Note:__ In order to preserve the intended design, at least one `SplitterElement` should have a dynamic `size`.",
-          "defaultValue": {
-            "value": "`\"auto\"`"
-          }
-        },
-        "minSize": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the minimum size of the `SplitterElement`. The resizer element stops when the minimum size is reached.",
-          "defaultValue": {
-            "value": "`0`"
-          }
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content which is shown inside the `SplitterElement`."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SplitterLayout": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A layout that contains several content areas. The content that is added to the `SplitterLayout` should be wrapped\ninto 0-n `SplitterElement`s which define the size and size constraints of the content area.\nThe orientation of the `SplitterLayout` can be set to horizontal (default) or vertical. All content areas of the\nlayout will be arranged in that way. In order to split vertically and horizontally at the same time, splitters need\nto be nested.\nBy adding or changing `SplitterElement`s to the `SplitterLayout` that make up the content areas, the size can be changed\nprogrammatically. Additionally, the content areas can be made non-resizable individually and a minimal size (in px)\ncan be set.\nThe splitter bars are focusable to enable resizing of the content areas via keyboard. The size of the content areas\ncan be manipulated when the splitter bar is focused and Left/Down/Right/Up are pressed.\n\n__Note:__ In order to preserve the intended design, at least one `SplitterElement` should have a dynamic `size`.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "vertical": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Controls if a vertical or horizontal `SplitterLayout` is rendered."
-        },
-        "children": {
-          "type": {
-            "name": "SplitterLayoutChild | SplitterLayoutChild[]"
-          },
-          "required": false,
-          "description": "The content areas (optional) to be split. The control will show n-1 splitter bars between n controls in this aggregation."
-        },
-        "options": {
-          "type": {
-            "name": "SplitterLayoutOptions"
-          },
-          "required": false,
-          "description": "Defines options to customize the behavior of the SplitterLayout."
-        },
-        "onResize": {
-          "type": {
-            "name": "(e: OnResizeParam) => void"
-          },
-          "required": false,
-          "description": "Fired when contents are resized.\n\n__Note:__\n- Resize events can fire many times in quick succession, it’s therefore strongly recommended to debounce your handler if you’re updating React state or causing other expensive operations.\n- The `areas` array reflects the logical position of the `SplitterElement`s relative to the \"Splitter\"."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ThemeProvider": {
-      "package": "@ui5/webcomponents-react",
-      "description": "In order to use `@ui5/webcomponents-react` you have to wrap your application's root component into the ThemeProvider.\n\n__Note:__ Per default, the `ThemeProvider` injects the CSS for the components during runtime. If you have imported our static CSS bundle/s in your application, you can set the prop `staticCssInjected` to `true` to prevent this.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "staticCssInjected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "You can set this flag to true in case you have imported our static CSS Bundle/s in your application.\nThis will prevent the ThemeProvider from injecting the CSS during runtime again.\n\n* __main:__ `import '@ui5/webcomponents-react/styles.css'`\n* __charts:__ `import '@ui5/webcomponents-react-charts/styles.css'`"
-        }
-      },
-      "methods": []
-    },
-    "VariantItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `VariantItem` describes a variant/view of the `VariantManagement` component.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "string"
-          },
-          "required": true,
-          "description": "The name of the variant.\n\n__Note:__ Variant names must be unique."
-        },
-        "author": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Author of the variant."
-        },
-        "favorite": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if favorites can be created.\n\n__Note:__ Has no effect if `showOnlyFavorites` is falsy in the `VariantMangament`."
-        },
-        "global": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicator if a variant is visible for all users (public flag is set)."
-        },
-        "isDefault": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicator if it's the default variant.\n\n__Note:__ There should only be __one__ default variant."
-        },
-        "labelReadOnly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if the variant title can be changed."
-        },
-        "applyAutomatically": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if the variant should be applied automatically on selection."
-        },
-        "applyAutomaticallyText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Text displayed next to the \"Apply Automatically\" checkbox inside the \"Manage Views\" dialog."
-        },
-        "readOnly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "If set to false, the user is allowed to change the item's data.\n\n__Note:__ When set to true, no \"Save\" button will be displayed for the `VariantItem` when the `VariantManagement` is in `dirtyState`."
-        },
-        "hideDelete": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if the variant can be deleted.\n\n__Note:__ If not set, a delete button is shown for all variants except for variants with `global={true}`."
-        },
-        "manageViewsInputProps": {
-          "type": {
-            "name": "Omit<InputPropTypes, \"value\">"
-          },
-          "required": false,
-          "description": "Defines the props of the input rendered with the `VariantItem` inside the \"Manage Views\" dialog.\n\n__Note:__ It is possible to overwrite internally used props. Please use with caution!"
-        },
-        "saveViewInputProps": {
-          "type": {
-            "name": "Omit<InputPropTypes, \"id\" | \"value\">"
-          },
-          "required": false,
-          "description": "Defines the props of the input rendered with the `VariantItem` inside the \"Save View\" dialog.\n\n__Note:__ It is possible to overwrite internally used props. Please use with caution!"
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text alternative of the component.\nNote: If not provided a default text alternative will be set, if present."
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ListItemStandardDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "VariantManagement": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The VariantManagement can be used to manage variants (views). You can use this component to create and maintain personalization changes.\n\n__Note:__ On the user interface, variants are generally referred to as \"views\".\n\n__Note:__ Each `VariantManagement` component can only have one default and one selected variant.\n\n__Note:__  You have to install `@ui5/webcomponents-fiori` to use this component.\n\n### Matching header styles\n\nTo ensure consistent header styles for different use-cases of the `VariantManagement`, we recommend setting the following styles to the `ui5-title` component:\n\n#### DynamicPage & ObjectPage\n\n- `font-family: var(--sapObjectHeader_Title_FontFamily);`\n\n__Header expanded__\n\n- `font-size: var(--sapObjectHeader_Title_FontSize);`\n\n__Header collapsed/snapped__\n\n- `font-size: var(--sapObjectHeader_Title_SnappedFontSize);`\n\n#### Tables\n\n- `font-size: var(--sapGroup_Title_FontSize);`\n\n#### Example\n\n```css\n.variantManagement [data-component-name=\"VariantManagementTitle\"] {\n    font-family: var(--sapObjectHeader_Title_FontFamily);\n    font-size: var(--sapObjectHeader_Title_FontSize);\n}\n```\n```jsx\n <VariantManagement className=\"variantManagement\">\n```\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Variant items displayed by the VariantManagement component.\n\n__Note:__ Although this prop accepts all HTML Elements, it is strongly recommended that you only use `VariantItem` in order to preserve the intended design."
-        },
-        "placement": {
-          "type": {
-            "name": "enum",
-            "raw": "PopoverPlacement | \"Start\" | \"End\" | \"Top\" | \"Bottom\"",
-            "value": [
-              {
-                "value": "\"Start\"",
-                "description": "Popover will be placed at the start of the reference element."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Popover will be placed at the end of the reference element."
-              },
-              {
-                "value": "\"Top\"",
-                "description": "Popover will be placed at the top of the reference element."
-              },
-              {
-                "value": "\"Bottom\"",
-                "description": "Popover will be placed at the bottom of the reference element."
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Top\""
-              },
-              {
-                "value": "\"Bottom\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines on which side the VariantManagement popover is placed at.",
-          "defaultValue": {
-            "value": "Bottom"
-          }
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Describes the title of the VariantManagement popover.\n\n__Note:__ If not set, the default title is used."
-        },
-        "closeOnItemSelect": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the VariantManagement should be closed if an item was selected."
-        },
-        "level": {
-          "type": {
-            "name": "enum",
-            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
-            "value": [
-              {
-                "value": "\"H1\"",
-                "description": "Renders `h1` tag."
-              },
-              {
-                "value": "\"H2\"",
-                "description": "Renders `h2` tag."
-              },
-              {
-                "value": "\"H3\"",
-                "description": "Renders `h3` tag."
-              },
-              {
-                "value": "\"H4\"",
-                "description": "Renders `h4` tag."
-              },
-              {
-                "value": "\"H5\"",
-                "description": "Renders `h5` tag."
-              },
-              {
-                "value": "\"H6\"",
-                "description": "Renders `h6` tag."
-              },
-              {
-                "value": "\"H1\""
-              },
-              {
-                "value": "\"H2\""
-              },
-              {
-                "value": "\"H3\""
-              },
-              {
-                "value": "\"H4\""
-              },
-              {
-                "value": "\"H5\""
-              },
-              {
-                "value": "\"H6\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Describes the `Title` HTML level (H1 - H6) of the selected variant. This property doesn't influence the style of the component, you can use the `size` prop for this purpose.",
-          "defaultValue": {
-            "value": "H4"
-          }
-        },
-        "size": {
-          "type": {
-            "name": "enum",
-            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
-            "value": [
-              {
-                "value": "\"H1\"",
-                "description": "Renders `h1` tag."
-              },
-              {
-                "value": "\"H2\"",
-                "description": "Renders `h2` tag."
-              },
-              {
-                "value": "\"H3\"",
-                "description": "Renders `h3` tag."
-              },
-              {
-                "value": "\"H4\"",
-                "description": "Renders `h4` tag."
-              },
-              {
-                "value": "\"H5\"",
-                "description": "Renders `h5` tag."
-              },
-              {
-                "value": "\"H6\"",
-                "description": "Renders `h6` tag."
-              },
-              {
-                "value": "\"H1\""
-              },
-              {
-                "value": "\"H2\""
-              },
-              {
-                "value": "\"H3\""
-              },
-              {
-                "value": "\"H4\""
-              },
-              {
-                "value": "\"H5\""
-              },
-              {
-                "value": "\"H6\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Describes the `Title`'s `size` of the selected variant.",
-          "defaultValue": {
-            "value": "H4"
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the VariantManagement is disabled."
-        },
-        "dirtyState": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicator for modified but not saved variants.\n\n__Note:__ You can change the indicator by setting `dirtyStateText`."
-        },
-        "dirtyStateText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Text for the dirty state indicator.",
-          "defaultValue": {
-            "value": "*"
-          }
-        },
-        "showOnlyFavorites": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates that the 'Favorites' feature is used. Only variants marked as favorites will be displayed in the variant list.\n\n__Note:__ Only if `showOnlyFavorites` is set to `true` favorites can be changed."
-        },
-        "hideSetAsDefault": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates that set as default is visible in the Save View and the Manage Views dialogs."
-        },
-        "hideShare": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates that the Public indicator is visible in the Save View and the Manage Views dialogs."
-        },
-        "hideApplyAutomatically": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates that Apply Automatically is visible in the Save View and the Manage Views dialogs."
-        },
-        "hideCreatedBy": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates that the Author is visible in the Manage Views dialog."
-        },
-        "hideSaveAs": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates that the Save View dialog button is visible."
-        },
-        "hideManageVariants": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates that the Manage Views dialog button is visible."
-        },
-        "inErrorState": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates that the control is in error state. If set to true error message will be displayed whenever the variant is opened."
-        },
-        "onSelect": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListDomRef, ListSelectionChangeEventDetail & { selectedVariant: SelectedVariant; }>) => void"
-          },
-          "required": false,
-          "description": "Fired after a variant has been selected.\n\n__Note:__ This event inherits part of its details from the `onSelectionChange` event of the `List` component."
-        },
-        "onSaveAs": {
-          "type": {
-            "name": "(e: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail> & { detail: SelectedVariant & { nativeDetail: number; }; }) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the \"Save\" button is clicked inside the Save View dialog.\n\n__Note:__ Calling `event.preventDefault()` prevents the dialog from closing when clicked."
-        },
-        "onSaveManageViews": {
-          "type": {
-            "name": "(e: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail> & { detail: { nativeDetail: number; deletedVariants: VariantItemPropTypes[]; prevVariants: VariantItemPropTypes[]; updatedVariants: UpdatedVariant[]; variants: SelectedVariant[]; }; }) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the \"Save\" button is clicked inside the Manage Views dialog.\n\n__Note:__ Calling `event.preventDefault()` prevents the dialog from closing when clicked."
-        },
-        "onSave": {
-          "type": {
-            "name": "(e: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail> & { detail: SelectedVariant & { nativeDetail: number; }; }) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the \"Save\" button is clicked in the `VariantManagement` popover.\n\n__Note:__ The save button is only displayed if the `VariantManagement` is in `dirtyState` and the selected variant is not in `readOnly` mode."
-        },
-        "onManageViewsCancel": {
-          "type": {
-            "name": "(e: (Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail> | Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) & { ...; }) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the \"Cancel\" button inside the Manage Views dialog is clicked or ESCAPE is pressed."
-        },
-        "onSaveViewCancel": {
-          "type": {
-            "name": "(e: (Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail> | Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) & { ...; }) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the \"Cancel\" button inside the Save View dialog is clicked or ESCAPE is pressed."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    }
-  },
-  "webComponents": {
-    "Avatar": {
-      "package": "@ui5/webcomponents-react",
-      "description": "An image-like component that has different display options for representing images and icons\nin different shapes and sizes, depending on the use case.\n\nThe shape can be circular or square. There are several predefined sizes, as well as an option to\nset a custom size.\n\n### Keyboard Handling\n\n- [Space] / [Enter] or [Return] - Fires the `click` event if the `mode` is set to `Interactive` or the deprecated `interactive` property is set to true.\n- [Shift] - If [Space] is pressed, pressing [Shift] releases the component without triggering the click event.\n\n\n\n__Note:__ This is a UI5 Web Component! [Avatar UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Avatar) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "badge": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the optional badge that will be used for visual affordance.\n\n**Recommendation:** While badges are supported on all avatars, it is recommended\nto use them with interactive avatars (via `mode=\"Interactive\"` or `interactive` attribute)\nto provide better user experience and accessibility.\n\n**Note:** While the slot allows for custom badges, to achieve\nthe Fiori design, use the `AvatarBadge` component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"badge\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.7.0](https://github.com/UI5/webcomponents/releases/tag/v1.7.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Receives the desired `<img>` tag\n\n**Note:** If you experience flickering of the provided image, you can hide the component until it is defined with the following CSS:<br/>\n`ui5-avatar:not(:defined) {`<br/>\n&nbsp;&nbsp;&nbsp;&nbsp;`visibility: hidden;`<br/>\n`}`\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<AvatarDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired on mouseup, space and enter if avatar is interactive\n\n**Note:** The event will not be fired if the `disabled`\nproperty is set to `true`.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "AvatarAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following field is supported:\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text alternative of the component.\nIf not provided a default text alternative will be set, if present."
-        },
-        "colorScheme": {
-          "type": {
-            "name": "enum",
-            "raw": "AvatarColorScheme | \"Auto\" | \"Accent1\" | \"Accent2\" | \"Accent3\" | \"Accent4\" | \"Accent5\" | \"Accent6\" | \"Accent7\" | \"Accent8\" | \"Accent9\" | \"Accent10\" | \"Placeholder\" | \"Transparent\"",
-            "value": [
-              {
-                "value": "\"Auto\""
-              },
-              {
-                "value": "\"Accent1\""
-              },
-              {
-                "value": "\"Accent2\""
-              },
-              {
-                "value": "\"Accent3\""
-              },
-              {
-                "value": "\"Accent4\""
-              },
-              {
-                "value": "\"Accent5\""
-              },
-              {
-                "value": "\"Accent6\""
-              },
-              {
-                "value": "\"Accent7\""
-              },
-              {
-                "value": "\"Accent8\""
-              },
-              {
-                "value": "\"Accent9\""
-              },
-              {
-                "value": "\"Accent10\""
-              },
-              {
-                "value": "\"Placeholder\""
-              },
-              {
-                "value": "\"Transparent\""
-              },
-              {
-                "value": "\"Auto\""
-              },
-              {
-                "value": "\"Accent1\""
-              },
-              {
-                "value": "\"Accent2\""
-              },
-              {
-                "value": "\"Accent3\""
-              },
-              {
-                "value": "\"Accent4\""
-              },
-              {
-                "value": "\"Accent5\""
-              },
-              {
-                "value": "\"Accent6\""
-              },
-              {
-                "value": "\"Accent7\""
-              },
-              {
-                "value": "\"Accent8\""
-              },
-              {
-                "value": "\"Accent9\""
-              },
-              {
-                "value": "\"Accent10\""
-              },
-              {
-                "value": "\"Placeholder\""
-              },
-              {
-                "value": "\"Transparent\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the background color of the desired image.\nIf `colorScheme` is set to `Auto`, the avatar will be displayed with the `Accent6` color.",
-          "defaultValue": {
-            "value": "\"Auto\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "fallbackIcon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the name of the fallback icon, which should be displayed in the following cases:\n\n\t- If the initials are not valid (more than 3 letters, unsupported languages or empty initials).\n\t- If there are three initials and they do not fit in the shape (e.g. WWW for some of the sizes).\n\t- If the image src is wrong.\n\n**Note:** If not set, a default fallback icon \"employee\" is displayed.\n\n**Note:** You should import the desired icon first, then use its name as \"fallback-icon\".\n\n`import \"@ui5/webcomponents-icons/dist/{icon_name}.js\"`\n\n`<Avatar fallback-icon=\"alert\">`\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html).",
-          "defaultValue": {
-            "value": "\"employee\""
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the name of the UI5 Icon, that will be displayed.\n\n**Note:** If `image` slot is provided, the property will be ignored.\n\n**Note:** You should import the desired icon first, then use its name as \"icon\".\n\n`import \"@ui5/webcomponents-icons/dist/{icon_name}.js\"`\n\n`<Avatar icon=\"employee\">`\n\n**Note:** If no icon or an empty one is provided, by default the \"employee\" icon should be displayed.\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "initials": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the displayed initials.\n\nUp to three Latin letters can be displayed as initials."
-        },
-        "interactive": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the avatar is interactive (focusable and pressable).\n\n**Note:** When set to `true`, this property takes precedence over the `mode` property,\nand the avatar will be rendered as interactive (role=\"button\", focusable) regardless of the `mode` value.\n\n**Note:** This property won't have effect if the `disabled`\nproperty is set to `true`.\n@deprecated Set `mode=\"Interactive\"` instead for the same functionality with proper accessibility.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "mode": {
-          "type": {
-            "name": "enum",
-            "raw": "AvatarMode | \"Image\" | \"Decorative\" | \"Interactive\"",
-            "value": [
-              {
-                "value": "\"Image\"",
-                "description": "Image mode (by default).\nConfigures the component to internally render role=\"img\"."
-              },
-              {
-                "value": "\"Decorative\"",
-                "description": "Decorative mode.\nConfigures the component to internally render role=\"presentation\" and aria-hidden=\"true\",\nmaking it purely decorative without semantic content or interactivity."
-              },
-              {
-                "value": "\"Interactive\"",
-                "description": "Interactive mode.\nConfigures the component to internally render role=\"button\".\nThis mode also supports focus and enables keyboard interaction."
-              },
-              {
-                "value": "\"Image\""
-              },
-              {
-                "value": "\"Decorative\""
-              },
-              {
-                "value": "\"Interactive\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the mode of the component.\n\n**Note:**\n- `Image` (default) - renders with role=\"img\"\n- `Decorative` - renders with role=\"presentation\" and aria-hidden=\"true\", making it purely decorative\n- `Interactive` - renders with role=\"button\", focusable (tabindex=\"0\"), and supports keyboard interaction\n\n**Note:** This property is ignored when the `interactive` property is set to `true`.\nIn that case, the avatar will always be rendered as interactive.\n\n**Note:** Available since [v2.20](https://github.com/UI5/webcomponents/releases/tag/v2.20) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Image\""
-          }
-        },
-        "shape": {
-          "type": {
-            "name": "enum",
-            "raw": "AvatarShape | \"Circle\" | \"Square\"",
-            "value": [
-              {
-                "value": "\"Circle\"",
-                "description": "Circular shape."
-              },
-              {
-                "value": "\"Square\"",
-                "description": "Square shape."
-              },
-              {
-                "value": "\"Circle\""
-              },
-              {
-                "value": "\"Square\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the shape of the component.",
-          "defaultValue": {
-            "value": "\"Circle\""
-          }
-        },
-        "size": {
-          "type": {
-            "name": "enum",
-            "raw": "AvatarSize | \"XS\" | \"S\" | \"M\" | \"L\" | \"XL\"",
-            "value": [
-              {
-                "value": "\"XS\"",
-                "description": "component size - 2rem\nfont size - 1rem"
-              },
-              {
-                "value": "\"S\"",
-                "description": "component size - 3rem\nfont size - 1.5rem"
-              },
-              {
-                "value": "\"M\"",
-                "description": "component size - 4rem\nfont size - 2rem"
-              },
-              {
-                "value": "\"L\"",
-                "description": "component size - 5rem\nfont size - 2.5rem"
-              },
-              {
-                "value": "\"XL\"",
-                "description": "component size - 7rem\nfont size - 3rem"
-              },
-              {
-                "value": "\"XS\""
-              },
-              {
-                "value": "\"S\""
-              },
-              {
-                "value": "\"M\""
-              },
-              {
-                "value": "\"L\""
-              },
-              {
-                "value": "\"XL\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines predefined size of the component.",
-          "defaultValue": {
-            "value": "\"S\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<AvatarDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "AvatarBadge": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `AvatarBadge` component is used to display a badge on top of `Avatar` component.\nThe badge can display an icon and supports different states for visual affordance.\n\n### Usage\n\nThe badge should be used as a child element of `Avatar` in the `badge` slot.\n\n```html\n<Avatar>\n  <AvatarBadge icon=\"edit\" slot=\"badge\"></AvatarBadge>\n</Avatar>\n```\n\n### Keyboard Handling\n\nThe badge does not receive keyboard focus.\n\n\n\n__Note:__ This is a UI5 Web Component! [AvatarBadge UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/AvatarBadge) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon name to be displayed inside the badge.\n\n**Note:** You should import the desired icon first, then use its name as \"icon\".\n\n`import \"@ui5/webcomponents-icons/dist/{icon_name}.js\"`"
-        },
-        "state": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the state of the badge, which determines its styling.\n\nAvailable options:\n- `None` (default) - Standard appearance\n- `Positive` - Green, used for success/approved states\n- `Critical` - Orange, used for warning states\n- `Negative` - Red, used for error/rejected states\n- `Information` - Blue, used for informational states",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<AvatarBadgeDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "AvatarGroup": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Displays a group of avatars arranged horizontally. It is useful to visually\nshowcase a group of related avatars, such as, project team members or employees.\n\nThe component allows you to display the avatars in different sizes,\ndepending on your use case.\n\nThe `AvatarGroup` component has two group types:\n\n- `Group` type: The avatars are displayed as partially overlapped on\ntop of each other and the entire group has one click/tap area.\n- `Individual` type: The avatars are displayed side-by-side and each\navatar has its own click/tap area.\n\n### Usage\n\nUse the `AvatarGroup` if:\n\n- You want to display a group of avatars.\n- You want to display several avatars which have something in common.\n\nDo not use the `AvatarGroup` if:\n\n- You want to display a single avatar.\n- You want to display a gallery for simple images.\n- You want to use it for other visual content than avatars.\n\n### Responsive Behavior\n\nWhen the available space is less than the width required to display all avatars,\nan overflow visualization appears as a button placed at the end with the same shape\nand size as the avatars. The visualization displays the number of avatars that have overflowed\nand are not currently visible.\n\n### Keyboard Handling\nThe component provides advanced keyboard handling.\nWhen focused, the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n`type` Individual:\n\n- [Tab] - Move focus to the overflow button\n- [Left] - Navigate one avatar to the left\n- [Right] - Navigate one avatar to the right\n- [Home] - Navigate to the first avatar\n- [End] - Navigate to the last avatar\n- [Space] / [Enter] or [Return] - Trigger `ui5-click` event\n\n`type` Group:\n\n- [Tab] - Move focus to the next interactive element after the component\n- [Space] / [Enter] or [Return] - Trigger `ui5-click` event\n\n__Note:__ This is a UI5 Web Component! [AvatarGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/AvatarGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the component. Use the `Avatar` component as an item.\n\n**Note:** The UX guidelines recommends using avatars with \"Circle\" shape.\n\nMoreover, if you use avatars with \"Square\" shape, there will be visual inconsistency\nas the built-in overflow action has \"Circle\" shape.\n\n__Supported Node Type/s:__ `Array<IAvatarGroupItem>`"
-        },
-        "overflowButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the overflow button of the component.\n\n**Note:** We recommend using the `Button` component.\n\n**Note:** If this slot is not used, the component will display the built-in overflow button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"overflowButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<AvatarGroupDomRef, AvatarGroupClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is activated either with a\nclick/tap or by using the Enter or Space key.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "overflowButtonClicked",
-                "type": "boolean",
-                "description": "indicates if the overflow button is clicked"
-              },
-              {
-                "name": "targetRef",
-                "type": "HTMLElement",
-                "description": "The DOM ref of the clicked item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": false
-          }
-        },
-        "onOverflow": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<AvatarGroupDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the count of visible `Avatar` elements in the\ncomponent has changed\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "AvatarGroupAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following field is supported:\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the AvatarGroup.\nWhen provided, this will override the default aria-label text.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(s) of the elements that describe the AvatarGroup.\nWhen provided, this will be used as aria-labelledby instead of aria-label.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents**."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "AvatarGroupType | \"Group\" | \"Individual\"",
-            "value": [
-              {
-                "value": "\"Group\"",
-                "description": "The avatars are displayed as partially overlapped on top of each other and the entire group has one click or tap area."
-              },
-              {
-                "value": "\"Individual\"",
-                "description": "The avatars are displayed side-by-side and each avatar has its own click or tap area."
-              },
-              {
-                "value": "\"Group\""
-              },
-              {
-                "value": "\"Individual\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the mode of the `AvatarGroup`.",
-          "defaultValue": {
-            "value": "\"Group\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<AvatarGroupDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Bar": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The Bar is a container which is primarily used to hold titles, buttons and input elements\nand its design and functionality is the basis for page headers and footers.\nThe component consists of three areas to hold its content - startContent slot, default slot and endContent slot.\nIt has the capability to center content, such as a title, while having other components on the left and right side.\n\n### Usage\nWith the use of the design property, you can set the style of the Bar to appear designed like a Header, Subheader, Footer and FloatingFooter.\n\n**Note:** Do not place a Bar inside another Bar or inside any bar-like component. Doing so may cause unpredictable behavior.\n\n### Responsive Behavior\nThe default slot will be centered in the available space between the startContent and the endContent areas,\ntherefore it might not always be centered in the entire bar.\n\n### Keyboard Handling\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [Bar UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Bar) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content in the middle of the bar.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "endContent": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content at the end of the bar.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"endContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "startContent": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content at the start of the bar.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"startContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the bar.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "BarAccessibleRole | \"Toolbar\" | \"None\"",
-            "value": [
-              {
-                "value": "\"Toolbar\"",
-                "description": "Represents the ARIA role \"toolbar\"."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Represents the ARIA role \"none\"."
-              },
-              {
-                "value": "\"Toolbar\""
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Specifies the ARIA role applied to the component for accessibility purposes.\n\n**Note:**\n\n- Set accessibleRole to \"toolbar\" only when the component contains two or more active, interactive elements (such as buttons, links, or input fields) within the bar.\n\n- If there is only one or no active element, it is recommended to avoid using the \"toolbar\" role, as it implies a grouping of multiple interactive controls.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Toolbar\""
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "BarDesign | \"Header\" | \"Subheader\" | \"Footer\" | \"FloatingFooter\"",
-            "value": [
-              {
-                "value": "\"Header\"",
-                "description": "Default type"
-              },
-              {
-                "value": "\"Subheader\"",
-                "description": "Subheader type"
-              },
-              {
-                "value": "\"Footer\"",
-                "description": "Footer type"
-              },
-              {
-                "value": "\"FloatingFooter\"",
-                "description": "Floating Footer type - there is visible border on all sides"
-              },
-              {
-                "value": "\"Header\""
-              },
-              {
-                "value": "\"Subheader\""
-              },
-              {
-                "value": "\"Footer\""
-              },
-              {
-                "value": "\"FloatingFooter\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component's design.",
-          "defaultValue": {
-            "value": "\"Header\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<BarDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "bar",
-          "description": "Used to style the wrapper of the content of the component"
-        },
-        {
-          "name": "endContent",
-          "description": "Used to style the wrapper of the end content of the component"
-        },
-        {
-          "name": "midContent",
-          "description": "Used to style the wrapper of the middle content of the component"
-        },
-        {
-          "name": "startContent",
-          "description": "Used to style the wrapper of the start content of the component"
-        }
-      ]
-    },
-    "BarcodeScannerDialog": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `BarcodeScannerDialog` component provides barcode scanning functionality for all devices that support the `MediaDevices.getUserMedia()` native API.\nOpening the dialog launches the device camera and scans for known barcode formats.\n\nA `scanSuccess` event fires whenever a barcode is identified\nand a `scanError` event fires when the scan failed (for example, due to missing permisions).\n\nInternally, the component  uses the zxing-js/library third party OSS.\n\nFor a list of supported barcode formats, see the [zxing-js/library](https://github.com/zxing-js/library) documentation.\n\n__Note:__ This is a UI5 Web Component! [BarcodeScannerDialog UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/BarcodeScannerDialog) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "footer": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the footer HTML Element.\n\n**Note:** When you provide custom content for the `footer` slot, the default close button is not rendered.\nThis means you need to include your own mechanism within the custom `footer` to close the dialog,\nsuch as a button with an event listener that closes the dialog.\n\n**Note:** If the `footer` slot is not provided, a default footer with a close button is rendered automatically,\nallowing users to close the dialog without any additional implementation.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header HTML Element.\n\n**Note:** If `header` slot is provided, the labelling of the dialog is a responsibility of the application developer.\n`accessibleName` should be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<BarcodeScannerDialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user closes the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onScanError": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<BarcodeScannerDialogDomRef, BarcodeScannerDialogScanErrorEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fires when the scan fails with error.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "message",
-                "type": "string",
-                "description": "the error message"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onScanSuccess": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<BarcodeScannerDialogDomRef, BarcodeScannerDialogScanSuccessEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fires when the scan is completed successfuuly.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "rawBytes",
-                "type": "Object",
-                "description": "the scan result as a Uint8Array"
-              },
-              {
-                "name": "text",
-                "type": "string",
-                "description": "the scan result as string"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the dialog is open.\n\n**Note:** Available since [v1.24.0](https://github.com/UI5/webcomponents/releases/tag/v1.24.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<BarcodeScannerDialogDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Breadcrumbs": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Enables users to navigate between items by providing a list of links to previous steps in the user's navigation path.\nIt helps the user to be aware of their location within the application and allows faster navigation.\n\nThe last three steps can be accessed as links directly, while the remaining links prior to them are available\nin a drop-down menu.\n\nYou can choose the type of separator to be used from a number of predefined options.\n\n### Keyboard Handling\nThe `Breadcrumbs` provides advanced keyboard handling.\n\n- [F4], [Alt] + [Up], [Alt] + [Down], [Space], or [Enter] - If the dropdown arrow is focused - opens/closes the drop-down.\n- [Space],[Enter] - Activates the focused item and triggers the `item-click` event.\n- [Escape] - Closes the drop-down.\n- [Left] - If the drop-down is closed - navigates one item to the left.\n- [Right] - If the drop-down is closed - navigates one item to the right.\n- [Up] - If the drop-down is open - moves focus to the next item.\n- [Down] - If the drop-down is open - moves focus to the previous item.\n- [Home] - Navigates to the first item.\n- [End] - Navigates to the last item.\n\n__Note:__ This is a UI5 Web Component! [Breadcrumbs UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Breadcrumbs) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the component items.\n\n**Note:** Use the `BreadcrumbsItem` component to define the desired items.\n\n__Supported Node Type/s:__ `Array<BreadcrumbsItem>`"
-        },
-        "onItemClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<BreadcrumbsDomRef, BreadcrumbsItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fires when a `BreadcrumbsItem` is clicked.\n\n**Note:** You can prevent browser location change by calling `event.preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "altKey",
-                "type": "Boolean",
-                "description": "Returns whether the \"ALT\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "ctrlKey",
-                "type": "Boolean",
-                "description": "Returns whether the \"CTRL\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The clicked item."
-              },
-              {
-                "name": "metaKey",
-                "type": "Boolean",
-                "description": "Returns whether the \"META\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "shiftKey",
-                "type": "Boolean",
-                "description": "Returns whether the \"SHIFT\" key was pressed when the event was triggered."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "BreadcrumbsDesign | \"Standard\" | \"NoCurrentPage\"",
-            "value": [
-              {
-                "value": "\"Standard\"",
-                "description": "Shows the current page as the last item in the trail.\nThe last item contains only plain text and is not a link."
-              },
-              {
-                "value": "\"NoCurrentPage\"",
-                "description": "All items are displayed as links."
-              },
-              {
-                "value": "\"Standard\""
-              },
-              {
-                "value": "\"NoCurrentPage\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the visual appearance of the last BreadcrumbsItem.\n\nThe Breadcrumbs supports two visual appearances for the last BreadcrumbsItem:\n- \"Standard\" - displaying the last item as \"current page\" (bold and without separator)\n- \"NoCurrentPage\" - displaying the last item as a regular BreadcrumbsItem, followed by separator",
-          "defaultValue": {
-            "value": "\"Standard\""
-          }
-        },
-        "separators": {
-          "type": {
-            "name": "enum",
-            "raw": "BreadcrumbsSeparator | \"Slash\" | \"BackSlash\" | \"DoubleBackSlash\" | \"DoubleGreaterThan\" | \"DoubleSlash\" | \"GreaterThan\"",
-            "value": [
-              {
-                "value": "\"Slash\"",
-                "description": "The separator appears as \"/\"."
-              },
-              {
-                "value": "\"BackSlash\"",
-                "description": "The separator appears as \"\\\"."
-              },
-              {
-                "value": "\"DoubleBackSlash\"",
-                "description": "The separator appears as \"\\\\\"."
-              },
-              {
-                "value": "\"DoubleGreaterThan\"",
-                "description": "The separator appears as \">>\"."
-              },
-              {
-                "value": "\"DoubleSlash\"",
-                "description": "The separator appears as \"//\" ."
-              },
-              {
-                "value": "\"GreaterThan\"",
-                "description": "The separator appears as \">\"."
-              },
-              {
-                "value": "\"Slash\""
-              },
-              {
-                "value": "\"BackSlash\""
-              },
-              {
-                "value": "\"DoubleBackSlash\""
-              },
-              {
-                "value": "\"DoubleGreaterThan\""
-              },
-              {
-                "value": "\"DoubleSlash\""
-              },
-              {
-                "value": "\"GreaterThan\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the visual style of the separator between the breadcrumb items.",
-          "defaultValue": {
-            "value": "\"Slash\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<BreadcrumbsDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "BreadcrumbsItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `BreadcrumbsItem` component defines the content of an item in `Breadcrumbs`.\n\n__Note:__ This is a UI5 Web Component! [BreadcrumbsItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/BreadcrumbsItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the item."
-        },
-        "href": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the link href.\n\n**Note:** Standard hyperlink behavior is supported."
-        },
-        "target": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the link target.\n\nAvailable options are:\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `_search`\n\n**Note:** This property must only be used when the `href` property is set."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<BreadcrumbsItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "BusyIndicator": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `BusyIndicator` signals that some operation is going on and that the\nuser must wait. It does not block the current UI screen so other operations could be triggered in parallel.\nIt displays 3 dots and each dot expands and shrinks at a different rate, resulting in a cascading flow of animation.\n\n### Usage\nFor the `BusyIndicator` you can define the size, the text and whether it is shown or hidden.\nIn order to hide it, use the \"active\" property.\n\nIn order to show busy state over an HTML element, simply nest the HTML element in a `BusyIndicator` instance.\n\n**Note:** Since `BusyIndicator` has `display: inline-block;` by default and no width of its own,\nwhenever you need to wrap a block-level element, you should set `display: block` to the busy indicator as well.\n\n#### When to use:\n\n- The user needs to be able to cancel the operation.\n- Only part of the application or a particular component is affected.\n\n#### When not to use:\n\n- The operation takes less than one second.\n- You need to block the screen and prevent the user from starting another activity.\n- Do not show multiple busy indicators at once.\n\n\n\n__Note:__ This is a UI5 Web Component! [BusyIndicator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/BusyIndicator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Determines the content over which the component will appear.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "active": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the busy indicator is visible on the screen. By default it is not.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "delay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the busy indicator will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "size": {
-          "type": {
-            "name": "enum",
-            "raw": "BusyIndicatorSize | \"S\" | \"M\" | \"L\"",
-            "value": [
-              {
-                "value": "\"S\"",
-                "description": "small size"
-              },
-              {
-                "value": "\"M\"",
-                "description": "medium size"
-              },
-              {
-                "value": "\"L\"",
-                "description": "large size"
-              },
-              {
-                "value": "\"S\""
-              },
-              {
-                "value": "\"M\""
-              },
-              {
-                "value": "\"L\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the size of the component.",
-          "defaultValue": {
-            "value": "\"M\""
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines text to be displayed below the component. It can be used to inform the user of the current operation."
-        },
-        "textPlacement": {
-          "type": {
-            "name": "enum",
-            "raw": "BusyIndicatorTextPlacement | \"Top\" | \"Bottom\"",
-            "value": [
-              {
-                "value": "\"Top\"",
-                "description": "The text will be displayed on top of the busy indicator."
-              },
-              {
-                "value": "\"Bottom\"",
-                "description": "The text will be displayed at the bottom of the busy indicator."
-              },
-              {
-                "value": "\"Top\""
-              },
-              {
-                "value": "\"Bottom\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the placement of the text.",
-          "defaultValue": {
-            "value": "\"Bottom\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<BusyIndicatorDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Button": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Button` component represents a simple push button.\nIt enables users to trigger actions by clicking or tapping the `Button`, or by pressing\ncertain keyboard keys, such as Enter.\n\n### Usage\n\nFor the `Button` UI, you can define text, icon, or both. You can also specify\nwhether the text or the icon is displayed first.\n\nYou can choose from a set of predefined types that offer different\nstyling to correspond to the triggered action.\n\nYou can set the `Button` as enabled or disabled. An enabled\n`Button` can be pressed by clicking or tapping it. The button changes\nits style to provide visual feedback to the user that it is pressed or hovered over with\nthe mouse cursor. A disabled `Button` appears inactive and cannot be pressed.\n\n\n\n__Note:__ This is a UI5 Web Component! [Button UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Button) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "badge": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Adds a badge to the button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"badge\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<ButtonBadge>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ButtonDomRef, ButtonClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is activated either with a mouse/tap or by using the Enter or Space key.\n\n**Note:** The event will not be fired if the `disabled` property is set to `true`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ButtonAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls, is currently expanded or collapsed.\nAccepts the following string values: `true` or `false`\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n- **ariaLabel**: Defines the accessible ARIA name of the component.\nAccepts any string value.\n\n - **ariaKeyShortcuts**: Defines keyboard shortcuts that activate or give focus to the button.\n\n- **controls**: Identifies the element (or elements) whose contents or presence are controlled by the button element.\nAccepts a lowercase string value.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "ButtonAccessibleRole | \"Button\" | \"Link\"",
-            "value": [
-              {
-                "value": "\"Button\"",
-                "description": "Represents Default (button) ARIA role."
-              },
-              {
-                "value": "\"Link\"",
-                "description": "Represents the ARIA role \"link\"."
-              },
-              {
-                "value": "\"Button\""
-              },
-              {
-                "value": "\"Link\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Describes the accessibility role of the button.\n\n**Note:** Use <code>ButtonAccessibleRole.Link</code> role only with a press handler, which performs a navigation. In all other scenarios the default button semantics are recommended.\n\n**Note:** Available since [v1.23](https://github.com/UI5/webcomponents/releases/tag/v1.23) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Button\""
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "ButtonDesign | \"Default\" | \"Positive\" | \"Negative\" | \"Transparent\" | \"Emphasized\" | \"Attention\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "default type (no special styling)"
-              },
-              {
-                "value": "\"Positive\"",
-                "description": "accept type (green button)"
-              },
-              {
-                "value": "\"Negative\"",
-                "description": "reject style (red button)"
-              },
-              {
-                "value": "\"Transparent\"",
-                "description": "transparent type"
-              },
-              {
-                "value": "\"Emphasized\"",
-                "description": "emphasized type"
-              },
-              {
-                "value": "\"Attention\"",
-                "description": "attention type"
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Transparent\""
-              },
-              {
-                "value": "\"Emphasized\""
-              },
-              {
-                "value": "\"Attention\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component design.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "endIcon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon, displayed as graphical element within the component after the button text.\n\n**Note:** It is highly recommended to use `endIcon` property only together with `icon` and/or `text` properties.\nUsage of `endIcon` only should be avoided.\n\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon, displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the button shows a loading indicator.\n\n**Note:** If set to `true`, a busy indicator component will be displayed on the related button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Specifies the delay in milliseconds before the loading indicator appears within the associated button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "submits": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "When set to `true`, the component will\nautomatically submit the nearest HTML form element on `press`.\n\n**Note:** This property is only applicable within the context of an HTML Form element.`\n@deprecated Set the \"type\" property to \"Submit\" to achieve the same result. The \"submits\" property is ignored if \"type\" is set to any value other than \"Button\".",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\n**Note:** A tooltip attribute should be provided for icon-only buttons, in order to represent their exact meaning/function.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Button\" | ButtonType | \"Submit\" | \"Reset\"",
-            "value": [
-              {
-                "value": "\"Button\""
-              },
-              {
-                "value": "\"Button\"",
-                "description": "The button does not do anything special when inside a form"
-              },
-              {
-                "value": "\"Submit\"",
-                "description": "The button acts as a submit button (submits a form)"
-              },
-              {
-                "value": "\"Reset\"",
-                "description": "The button acts as a reset button (resets a form)"
-              },
-              {
-                "value": "\"Submit\""
-              },
-              {
-                "value": "\"Reset\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines whether the button has special form-related functionality.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Button\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ButtonDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ButtonBadge": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ButtonBadge` component defines a badge that appears in the `Button`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ButtonBadge UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ButtonBadge) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "ButtonBadgeDesign | \"InlineText\" | \"OverlayText\" | \"AttentionDot\"",
-            "value": [
-              {
-                "value": "\"InlineText\"",
-                "description": "The badge is displayed after the text, inside the button."
-              },
-              {
-                "value": "\"OverlayText\"",
-                "description": "The badge is displayed at the top-end corner of the button.\n\n**Note:** According to design guidance, the OverlayText design mode is best used in cozy density to avoid potential visual issues in compact."
-              },
-              {
-                "value": "\"AttentionDot\"",
-                "description": "The badge is displayed as an attention dot."
-              },
-              {
-                "value": "\"InlineText\""
-              },
-              {
-                "value": "\"OverlayText\""
-              },
-              {
-                "value": "\"AttentionDot\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the badge placement and appearance.\n- **InlineText** - displayed inside the button after its text, and recommended for **compact** density.\n- **OverlayText** - displayed at the top-end corner of the button, and recommended for **cozy** density.\n- **AttentionDot** - displayed at the top-end corner of the button as a dot, and suitable for both **cozy** and **compact** densities.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"AttentionDot\""
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Text is not applied when the `design` property is set to `AttentionDot`.\n\n**Note:** The badge component only accepts numeric values and the \"+\" symbol. Using other characters or formats may result in unpredictable behavior, which is not guaranteed or supported.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ButtonBadgeDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Calendar": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Calendar` component allows users to select one or more dates.\n\nCurrently selected dates are represented with instances of `CalendarDate` as\nchildren of the `Calendar`. The value property of each `CalendarDate` must be a\ndate string, correctly formatted according to the `Calendar`'s `formatPattern` property.\nWhenever the user changes the date selection, `Calendar` will automatically create/remove instances\nof `CalendarDate` in itself, unless you prevent this behavior by calling `preventDefault()` for the\n`selection-change` event. This is useful if you want to control the selected dates externally.\n\n### Usage\n\nThe user can navigate to a particular date by:\n\n- Pressing over a month inside the months view\n- Pressing over an year inside the years view\n\nThe user can confirm a date selection by pressing over a date inside the days view.\n\n### Keyboard Handling\nThe `Calendar` provides advanced keyboard handling.\nWhen a picker is showed and focused the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- Day picker:\n\n- [F4] - Shows month picker\n- [Shift] + [F4] - Shows year picker\n- [Page Up] - Navigate to the previous month\n- [Page Down] - Navigate to the next month\n- [Shift] + [Page Up] - Navigate to the previous year\n- [Shift] + [Page Down] - Navigate to the next year\n- [Ctrl] + [Shift] + [Page Up] - Navigate ten years backwards\n- [Ctrl] + [Shift] + [Page Down] - Navigate ten years forwards\n- [Home] - Navigate to the first day of the week\n- [End] - Navigate to the last day of the week\n- [Ctrl] + [Home] - Navigate to the first day of the month\n- [Ctrl] + [End] - Navigate to the last day of the month\n\n- Month picker:\n\n- [Page Up] - Navigate to the previous year\n- [Page Down] - Navigate to the next year\n- [Home] - Navigate to the first month of the current row\n- [End] - Navigate to the last month of the current row\n- [Ctrl] + [Home] - Navigate to the first month of the current year\n- [Ctrl] + [End] - Navigate to the last month of the year\n\n- Year picker:\n\n- [Page Up] - Navigate to the previous year range\n- [Page Down] - Navigate the next year range\n- [Home] - Navigate to the first year of the current row\n- [End] - Navigate to the last year of the current row\n- [Ctrl] + [Home] - Navigate to the first year of the current year range\n- [Ctrl] + [End] - Navigate to the last year of the current year range\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n### Calendar types\nThe component supports several calendar types - Gregorian, Buddhist, Islamic, Japanese and Persian.\nBy default the Gregorian Calendar is used. In order to use the Buddhist, Islamic, Japanese or Persian calendar,\nyou need to set the `primaryCalendarType` property and import one or more of the following modules:\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Buddhist.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Islamic.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Japanese.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Persian.js\";`\n\nOr, you can use the global configuration and set the `calendarType` key:\n\n```html\n<script data-id=\"sap-ui-config\" type=\"application/json\">\n\t{\n\t\t\"calendarType\": \"Japanese\"\n\t}\n</script>\n```\n\n\n\n__Note:__ This is a UI5 Web Component! [Calendar UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Calendar) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "calendarLegend": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the calendar legend of the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"calendarLegend\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<CalendarLegend>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the selected date or dates (depending on the `selectionMode` property)\nfor this calendar as instances of `CalendarDate` or `CalendarDateRange`.\nUse `CalendarDate` for single or multiple selection, and `CalendarDateRange` for range selection.\n\n__Supported Node Type/s:__ `Array<ICalendarSelectedDates>`"
-        },
-        "disabledDates": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the disabled date ranges that cannot be selected in the calendar.\nUse `CalendarDateRange` elements to specify ranges of disabled dates.\nEach range can define a start date, an end date, or both.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"disabledDates\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<CalendarDateRange>`"
-        },
-        "specialDates": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the special dates, visually emphasized in the calendar.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"specialDates\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<SpecialCalendarDate>`"
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<CalendarDomRef, CalendarSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the selected dates change.\n\n**Note:** If you call `preventDefault()` for this event, the component will not\ncreate instances of `CalendarDate` for the newly selected dates. In that case you should do this manually.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "selectedDates",
-                "type": "Array<number>",
-                "description": "The selected dates as UTC timestamps"
-              },
-              {
-                "name": "selectedValues",
-                "type": "Array<string>",
-                "description": "The selected dates"
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "calendarWeekNumbering": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarWeekNumbering | \"Default\" | \"ISO_8601\" | \"MiddleEastern\" | \"WesternTraditional\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "The default calendar week numbering:\n\nThe framework determines the week numbering scheme; currently it is derived from the\nactive format locale. Future versions of ui5-webcomponents might select a different week numbering\nscheme."
-              },
-              {
-                "value": "\"ISO_8601\"",
-                "description": "Official calendar week numbering in most of Europe (ISO 8601 standard):\nMonday is first day of the week, the week containing January 4th is first week of the year."
-              },
-              {
-                "value": "\"MiddleEastern\"",
-                "description": "Official calendar week numbering in much of the Middle East (Middle Eastern calendar):\nSaturday is first day of the week, the week containing January 1st is first week of the year."
-              },
-              {
-                "value": "\"WesternTraditional\"",
-                "description": "Official calendar week numbering in the United States, Canada, Brazil, Israel, Japan, and\nother countries (Western traditional calendar):\nSunday is first day of the week, the week containing January 1st is first week of the year."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"ISO_8601\""
-              },
-              {
-                "value": "\"MiddleEastern\""
-              },
-              {
-                "value": "\"WesternTraditional\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines how to calculate calendar weeks and first day of the week.\nIf not set, the calendar will be displayed according to the currently set global configuration.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "displayFormat": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, displayed in the input field.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "formatPattern": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, displayed in the input field.\n@deprecated Use displayFormat and valueFormat instead"
-        },
-        "hideWeekNumbers": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the visibility of the week numbers column.\n\n**Note:** For calendars other than Gregorian,\nthe week numbers are not displayed regardless of what is set.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "maxDate": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the maximum date available for selection.\n\n**Note:** If the formatPattern property is not set, the maxDate value must be provided in the ISO date format (yyyy-MM-dd)."
-        },
-        "minDate": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the minimum date available for selection.\n\n**Note:** If the formatPattern property is not set, the minDate value must be provided in the ISO date format (yyyy-MM-dd)."
-        },
-        "primaryCalendarType": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
-            "value": [
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              },
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Sets a calendar type used for display.\nIf not set, the calendar type of the global configuration is used."
-        },
-        "secondaryCalendarType": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
-            "value": [
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              },
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the secondary calendar type.\nIf not set, the calendar will only show the primary calendar type."
-        },
-        "selectionMode": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarSelectionMode | \"Single\" | \"Multiple\" | \"Range\"",
-            "value": [
-              {
-                "value": "\"Single\"",
-                "description": "Only one date can be selected at a time"
-              },
-              {
-                "value": "\"Multiple\"",
-                "description": "Several dates can be selected"
-              },
-              {
-                "value": "\"Range\"",
-                "description": "A range defined by a start date and an end date can be selected"
-              },
-              {
-                "value": "\"Single\""
-              },
-              {
-                "value": "\"Multiple\""
-              },
-              {
-                "value": "\"Range\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the type of selection used in the calendar component.\nAccepted property values are:\n\n- `CalendarSelectionMode.Single` - enables a single date selection.(default value)\n- `CalendarSelectionMode.Range` - enables selection of a date range.\n- `CalendarSelectionMode.Multiple` - enables selection of multiple dates.",
-          "defaultValue": {
-            "value": "\"Single\""
-          }
-        },
-        "valueFormat": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, used for the value attribute.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<CalendarDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "calendar-header-arrow-button",
-          "description": "Used to style the calendar header navigation arrow buttons (previous/next buttons)."
-        },
-        {
-          "name": "calendar-header-middle-button",
-          "description": "Used to style the calendar header middle buttons (month/year/year-range buttons)."
-        },
-        {
-          "name": "day-cell",
-          "description": "Used to style the day cells."
-        },
-        {
-          "name": "day-cell-selected",
-          "description": "Used to style the day cells when selected."
-        },
-        {
-          "name": "day-cell-selected-between",
-          "description": "Used to style the day cells in between of selected dates in range."
-        },
-        {
-          "name": "month-cell",
-          "description": "Used to style the month cells."
-        },
-        {
-          "name": "month-cell-selected",
-          "description": "Used to style the month cells when selected."
-        },
-        {
-          "name": "month-cell-selected-between",
-          "description": "Used to style the day cells in between of selected months in range."
-        },
-        {
-          "name": "month-picker-root",
-          "description": "Used to style the month picker root container."
-        },
-        {
-          "name": "year-cell",
-          "description": "Used to style the year cells."
-        },
-        {
-          "name": "year-cell-selected",
-          "description": "Used to style the year cells when selected."
-        },
-        {
-          "name": "year-cell-selected-between",
-          "description": "Used to style the year cells in between of selected years in range."
-        },
-        {
-          "name": "year-picker-root",
-          "description": "Used to style the year picker root container."
-        },
-        {
-          "name": "year-range-cell",
-          "description": "Used to style the year range cells."
-        },
-        {
-          "name": "year-range-cell-selected",
-          "description": "Used to style the year range cells when selected."
-        },
-        {
-          "name": "year-range-cell-selected-between",
-          "description": "Used to style the year range cells in between of selected year ranges."
-        },
-        {
-          "name": "year-range-picker-root",
-          "description": "Used to style the year range picker root container."
-        }
-      ]
-    },
-    "CalendarDate": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `CalendarDate` component defines a calendar date to be used inside `Calendar`\n\n__Note:__ This is a UI5 Web Component! [CalendarDate UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CalendarDate) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "The date formatted according to the `formatPattern` property\nof the `Calendar` that hosts the component."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<CalendarDateDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "CalendarDateRange": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `CalendarDateRange` component defines a range of dates to be used inside `Calendar`\n\n__Note:__ This is a UI5 Web Component! [CalendarDateRange UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CalendarDateRange) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "endValue": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "End of date range formatted according to the `formatPattern` property\nof the `Calendar` that hosts the component."
-        },
-        "startValue": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Start of date range formatted according to the `formatPattern` property\nof the `Calendar` that hosts the component."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<CalendarDateRangeDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "CalendarLegend": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `CalendarLegend` component is designed for use within the `Calendar` to display a legend.\nEach `CalendarLegendItem` represents a unique date type, specifying its visual style\nand a corresponding textual label.\n\n\n\n__Note:__ This is a UI5 Web Component! [CalendarLegend UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CalendarLegend) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the component.\n\n__Supported Node Type/s:__ `Array<CalendarLegendItem>`"
-        },
-        "hideNonWorkingDay": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Hides the Non-Working day item in the legend.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideSelectedDay": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Hides the Selected day item in the legend.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideToday": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Hides the Today item in the legend.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideWorkingDay": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Hides the Working day item in the legend.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<CalendarLegendDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "CalendarLegendItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Each `CalendarLegendItem` represents a legend item, displaying a color with a label.\nThe color is determined by the `type` property and the label by the `text` property.\nIf a `SpecialCalendarDate` is used within the `Calendar` and a type is set, clicking on a `CalendarLegendItem`\nwith the same type will emphasize the respective date(s) in the calendar.\n\n### Usage\nThe `CalendarLegendItem` is intended to be used within the `CalendarLegend` component.\n\n\n\n__Note:__ This is a UI5 Web Component! [CalendarLegendItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CalendarLegendItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text content of the Calendar Legend Item."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarLegendItemType | \"Today\" | \"Selected\" | \"None\" | \"Working\" | \"NonWorking\" | \"Type01\" | \"Type02\" | \"Type03\" | \"Type04\" | \"Type05\" | \"Type06\" | ... 13 more ... | \"Type20\"",
-            "value": [
-              {
-                "value": "\"Today\"",
-                "description": "Represents the \"Today\" item in the calendar legend."
-              },
-              {
-                "value": "\"Selected\"",
-                "description": "Represents the \"Selected\" item in the calendar legend."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Set when no type is set."
-              },
-              {
-                "value": "\"Working\"",
-                "description": "Represents the \"Working\" item in the calendar legend."
-              },
-              {
-                "value": "\"NonWorking\"",
-                "description": "Represents the \"NonWorking\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type01\"",
-                "description": "Represents the \"Type01\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type02\"",
-                "description": "Represents the \"Type02\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type03\"",
-                "description": "Represents the \"Type03\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type04\"",
-                "description": "Represents the \"Type04\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type05\"",
-                "description": "Represents the \"Type05\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type06\"",
-                "description": "Represents the \"Type06\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type07\"",
-                "description": "Represents the \"Type07\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type08\"",
-                "description": "Represents the \"Type08\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type09\"",
-                "description": "Represents the \"Type09\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type10\"",
-                "description": "Represents the \"Type10\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type11\"",
-                "description": "Represents the \"Type11\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type12\"",
-                "description": "Represents the \"Type12\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type13\"",
-                "description": "Represents the \"Type13\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type14\"",
-                "description": "Represents the \"Type14\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type15\"",
-                "description": "Represents the \"Type15\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type16\"",
-                "description": "Represents the \"Type16\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type17\"",
-                "description": "Represents the \"Type17\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type18\"",
-                "description": "Represents the \"Type18\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type19\"",
-                "description": "Represents the \"Type19\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type20\"",
-                "description": "Represents the \"Type20\" item in the calendar legend."
-              },
-              {
-                "value": "\"Today\""
-              },
-              {
-                "value": "\"Selected\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Working\""
-              },
-              {
-                "value": "\"NonWorking\""
-              },
-              {
-                "value": "\"Type01\""
-              },
-              {
-                "value": "\"Type02\""
-              },
-              {
-                "value": "\"Type03\""
-              },
-              {
-                "value": "\"Type04\""
-              },
-              {
-                "value": "\"Type05\""
-              },
-              {
-                "value": "\"Type06\""
-              },
-              {
-                "value": "\"Type07\""
-              },
-              {
-                "value": "\"Type08\""
-              },
-              {
-                "value": "\"Type09\""
-              },
-              {
-                "value": "\"Type10\""
-              },
-              {
-                "value": "\"Type11\""
-              },
-              {
-                "value": "\"Type12\""
-              },
-              {
-                "value": "\"Type13\""
-              },
-              {
-                "value": "\"Type14\""
-              },
-              {
-                "value": "\"Type15\""
-              },
-              {
-                "value": "\"Type16\""
-              },
-              {
-                "value": "\"Type17\""
-              },
-              {
-                "value": "\"Type18\""
-              },
-              {
-                "value": "\"Type19\""
-              },
-              {
-                "value": "\"Type20\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the type of the Calendar Legend Item.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<CalendarLegendItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Card": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Card` is a component that represents information in the form of a\ntile with separate header and content areas.\nThe content area of a `Card` can be arbitrary HTML content.\nThe header can be used through slot `header`. For which there is a `CardHeader` component to achieve the card look and feel.\n\nNote: We recommend the usage of `CardHeader` for the header slot, so advantage can be taken for keyboard handling, styling and accessibility.\n\n\n\n`import \"@ui5/webcomponents/dist/CardHeader.js\";` (for `CardHeader`)\n\n__Note:__ This is a UI5 Web Component! [Card UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Card) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header of the component.\n\n**Note:** Use `CardHeader` for the intended design.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<CardHeader>`"
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component, which is used as the name of the card region and should be unique per card.\n\n**Note:** `accessibleName` should be always set, unless `accessibleNameRef` is set."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that label the component."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if a loading indicator would be displayed over the card.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the loading indicator will show up for this card.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<CardDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "content",
-          "description": "Used to style the content of the card"
-        },
-        {
-          "name": "root",
-          "description": "Used to style the root DOM element of the card component"
-        }
-      ]
-    },
-    "CardHeader": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `CardHeader` is a component, meant to be used as a header of the `Card` component.\nIt displays valuable information, that can be defined with several properties, such as: `titleText`, `subtitleText`, `additionalText`\nand two slots: `avatar` and `action`.\n\n### Keyboard handling\nIn case you enable `interactive` property, you can press the `CardHeader` by Space and Enter keys.\n\n\n\n__Note:__ This is a UI5 Web Component! [CardHeader UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CardHeader) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "action": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines an action, displayed in the right most part of the header.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"action\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "avatar": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines an avatar image, displayed in the left most part of the header.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"avatar\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<CardHeaderDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is activated by mouse/tap or by using the Enter or Space key.\n\n**Note:** The event would be fired only if the `interactive` property is set to true.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "additionalText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the additional text."
-        },
-        "interactive": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the component would be interactive,\ne.g gets hover effect and `click` event is fired, when pressed.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "subtitleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the subtitle text."
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the title text."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<CardHeaderDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "additional-text",
-          "description": "Used to style the additional text of the CardHeader"
-        },
-        {
-          "name": "root",
-          "description": "Used to style the root DOM element of the CardHeader"
-        },
-        {
-          "name": "subtitle",
-          "description": "Used to style the subtitle of the CardHeader"
-        },
-        {
-          "name": "title",
-          "description": "Used to style the title of the CardHeader"
-        }
-      ]
-    },
-    "Carousel": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The Carousel allows the user to browse through a set of items.\nThe component is mostly used for showing a gallery of images, but can hold any other HTML element.\n\nThere are several ways to perform navigation:\n\n- on desktop - the user can navigate using the navigation arrows or with keyboard shortcuts.\n- on touch devices - the user can navigate using the navigation arrows (always visible) or can use swipe gestures.\n\n### Usage\n\n#### When to use:\n\n- The items you want to display are very different from each other.\n- You want to display the items one after the other.\n\n#### When not to use:\n\n- The items you want to display need to be visible at the same time.\n- The items you want to display are uniform and very similar.\n\n### Hidden Items\n\nCarousel items can be conditionally hidden by adding the `hidden` attribute to any child element.\nHidden items are automatically excluded from carousel navigation and will not be displayed or counted in pagination.\nThis allows for dynamic showing or hiding of carousel items without affecting the overall carousel behavior.\n\n### Keyboard Handling\n\n#### Basic Navigation\nWhen the `Carousel` is focused the user can navigate between the items\nwith the following keyboard shortcuts:\n\n- [Up] or [Down] - Navigates to previous and next item\n- [Left] or [Right] - Navigates to previous and next item\n\n### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [Carousel UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Carousel) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component.\n\n**Note:** Items with the `hidden` attribute will be automatically excluded from carousel navigation and page calculations.\nThey will not be displayed or accessible via keyboard navigation. See [sample](./#carousel-with-hidden-items).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onNavigate": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<CarouselDomRef, CarouselNavigateEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired whenever the page changes due to user interaction,\nwhen the user clicks on the navigation arrows or while resizing,\nbased on the `items-per-page` property.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "selectedIndex",
-                "type": "Integer",
-                "description": "the current selected index"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that label the input.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**."
-        },
-        "arrowsPlacement": {
-          "type": {
-            "name": "enum",
-            "raw": "CarouselArrowsPlacement | \"Content\" | \"Navigation\"",
-            "value": [
-              {
-                "value": "\"Content\"",
-                "description": "Carousel arrows are placed on the sides of the current Carousel page."
-              },
-              {
-                "value": "\"Navigation\"",
-                "description": "Carousel arrows are placed on the sides of the page indicator of the Carousel."
-              },
-              {
-                "value": "\"Content\""
-              },
-              {
-                "value": "\"Navigation\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the position of arrows.\n\nAvailable options are:\n\n- `Content` - the arrows are placed on the sides of the current page.\n- `Navigation` - the arrows are placed on the sides of the page indicator.",
-          "defaultValue": {
-            "value": "\"Content\""
-          }
-        },
-        "backgroundDesign": {
-          "type": {
-            "name": "enum",
-            "raw": "BackgroundDesign | \"Solid\" | \"Transparent\" | \"Translucent\"",
-            "value": [
-              {
-                "value": "\"Solid\"",
-                "description": "A solid background color dependent on the theme."
-              },
-              {
-                "value": "\"Transparent\"",
-                "description": "Transparent background."
-              },
-              {
-                "value": "\"Translucent\"",
-                "description": "A translucent background depending on the opacity value of the theme."
-              },
-              {
-                "value": "\"Solid\""
-              },
-              {
-                "value": "\"Transparent\""
-              },
-              {
-                "value": "\"Translucent\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the carousel's background design.\n\n**Note:** Available since [v1.14](https://github.com/UI5/webcomponents/releases/tag/v1.14) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Translucent\""
-          }
-        },
-        "cyclic": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the carousel should loop, i.e show the first page after the last page is reached and vice versa.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideNavigationArrows": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the visibility of the navigation arrows.\nIf set to true the navigation arrows will be hidden.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hidePageIndicator": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the visibility of the page indicator.\nIf set to true the page indicator will be hidden.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "itemsPerPage": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the number of items per page depending on the carousel width.\n\n- 'S' for screens smaller than 600 pixels.\n- 'M' for screens greater than or equal to 600 pixels and smaller than 1024 pixels.\n- 'L' for screens greater than or equal to 1024 pixels and smaller than 1440 pixels.\n- 'XL' for screens greater than or equal to 1440 pixels.\n\nOne item per page is shown by default.",
-          "defaultValue": {
-            "value": "\"S1 M1 L1 XL1\""
-          }
-        },
-        "pageIndicatorBackgroundDesign": {
-          "type": {
-            "name": "enum",
-            "raw": "BackgroundDesign | \"Solid\" | \"Transparent\" | \"Translucent\"",
-            "value": [
-              {
-                "value": "\"Solid\"",
-                "description": "A solid background color dependent on the theme."
-              },
-              {
-                "value": "\"Transparent\"",
-                "description": "Transparent background."
-              },
-              {
-                "value": "\"Translucent\"",
-                "description": "A translucent background depending on the opacity value of the theme."
-              },
-              {
-                "value": "\"Solid\""
-              },
-              {
-                "value": "\"Transparent\""
-              },
-              {
-                "value": "\"Translucent\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the page indicator background design.\n\n**Note:** Available since [v1.14](https://github.com/UI5/webcomponents/releases/tag/v1.14) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Solid\""
-          }
-        },
-        "pageIndicatorBorderDesign": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Solid\" | BorderDesign | \"None\"",
-            "value": [
-              {
-                "value": "\"Solid\""
-              },
-              {
-                "value": "\"Solid\"",
-                "description": "A solid border color dependent on the theme."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Specifies no border."
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the page indicator border design.\n\n**Note:** Available since [v1.14](https://github.com/UI5/webcomponents/releases/tag/v1.14) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Solid\""
-          }
-        },
-        "pageIndicatorType": {
-          "type": {
-            "name": "enum",
-            "raw": "CarouselPageIndicatorType | \"Default\" | \"Numeric\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "The page indicator will be visualized as dots if there are fewer than 9 pages.\nIf there are more pages, the page indicator will switch to displaying the current page and the total number of pages. (e.g. X of Y)"
-              },
-              {
-                "value": "\"Numeric\"",
-                "description": "The page indicator will display the current page and the total number of pages. (e.g. X of Y)"
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Numeric\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the style of the page indicator.\nAvailable options are:\n\n- `Default` - The page indicator will be visualized as dots if there are fewer than 9 pages. If there are more pages, the page indicator will switch to displaying the current page and the total number of pages. (e.g. X of Y)\n- `Numeric` - The page indicator will display the current page and the total number of pages. (e.g. X of Y)\n\n**Note:** Available since [v1.10](https://github.com/UI5/webcomponents/releases/tag/v1.10) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<CarouselDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "navigateTo",
-          "description": "Changes the currently displayed page.",
-          "params": [
-            {
-              "name": "itemIndex",
-              "type": {
-                "name": "number"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "void"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "content",
-          "description": "Used to style the content of the component"
-        }
-      ]
-    },
-    "CheckBox": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Allows the user to set a binary value, such as true/false or yes/no for an item.\n\nThe `CheckBox` component consists of a box and a label that describes its purpose.\nIf it's checked, an indicator is displayed inside the box.\nTo check/uncheck the `CheckBox`, the user has to click or tap the square\nbox or its label.\n\nThe `CheckBox` component only has 2 states - checked and unchecked.\nClicking or tapping toggles the `CheckBox` between checked and unchecked state.\n\n### Usage\n\nYou can define the checkbox text with via the `text` property. If the text exceeds the available width, it is truncated by default.\nIn case you prefer text to truncate, set the `wrappingType` property to \"None\".\nThe touchable area for toggling the `CheckBox` ends where the text ends.\n\nYou can disable the `CheckBox` by setting the `disabled` property to\n`true`,\nor use the `CheckBox` in read-only mode by setting the `readonly`\nproperty to `true`.\n\n### Keyboard Handling\n\nThe user can use the following keyboard shortcuts to toggle the checked state of the `CheckBox`.\n\n- [Space],[Enter] - Toggles between different states: checked, not checked.\n\n\n\n__Note:__ This is a UI5 Web Component! [CheckBox UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/CheckBox) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<CheckBoxDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component checked state changes.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "checked": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the component is checked.\n\n**Note:** The property can be changed with user interaction,\neither by cliking/tapping on the component, or by\npressing the Enter or Space key.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "displayOnly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the `CheckBox` is in display only state.\n\nWhen set to `true`, the `CheckBox` is not interactive, not editable, not focusable\nand not in the tab chain. This setting is used for forms in review mode.\n\n**Note:** When the property `disabled` is set to `true` this property has no effect.\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "indeterminate": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is displayed as partially checked.\n\n**Note:** The indeterminate state can be set only programmatically and can’t be achieved by user\ninteraction and the resulting visual state depends on the values of the `indeterminate`\nand `checked` properties:\n\n-  If the component is checked and indeterminate, it will be displayed as partially checked\n-  If the component is checked and it is not indeterminate, it will be displayed as checked\n-  If the component is not checked, it will be displayed as not checked regardless value of the indeterminate attribute",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.\n\n**Note:** We advise against using the text property of the checkbox when there is a\nlabel associated with it to avoid having two required asterisks.\n\n**Note:** Available since [v1.3.0](https://github.com/UI5/webcomponents/releases/tag/v1.3.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the component."
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the form value of the component that is submitted when the checkbox is checked.\n\nWhen a form containing `CheckBox` elements is submitted, only the values of the\n**checked** checkboxes are included in the form data sent to the server. Unchecked\ncheckboxes do not contribute any data to the form submission.\n\nThis property is particularly useful for **checkbox groups**, where multiple checkboxes with the same `name` but different `value` properties can be used to represent a set of related options.",
-          "defaultValue": {
-            "value": "\"on\""
-          }
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | WrappingType | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines whether the component text wraps when there is not enough space.\n\n**Note:** for option \"Normal\" the text will wrap and the words will not be broken based on hyphenation.\n**Note:** for option \"None\" the text will be truncated with an ellipsis.",
-          "defaultValue": {
-            "value": "\"Normal\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<CheckBoxDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "icon",
-          "description": "Used to style the icon of the `ui5-checkbox`"
-        },
-        {
-          "name": "label",
-          "description": "Used to style the label of the `ui5-checkbox`"
-        },
-        {
-          "name": "root",
-          "description": "Used to style the outermost wrapper of the `ui5-checkbox`"
-        }
-      ]
-    },
-    "ColorPalette": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ColorPalette` provides the users with a range of predefined colors. The colors are fixed and do not change with the theme.\n\n### Usage\n\nThe `ColorPalette` is meant for users that need to select a color from a predefined set.\nTo define the colors, use the `ColorPaletteItem` component inside the default slot of the `ColorPalette`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ColorPalette UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ColorPalette) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the `ColorPaletteItem` elements.\n\n__Supported Node Type/s:__ `Array<IColorPaletteItem>`"
-        },
-        "onItemClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ColorPaletteDomRef, ColorPaletteItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user selects a color.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "color",
-                "type": "string",
-                "description": "the selected color"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": false
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ColorPaletteDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ColorPaletteItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ColorPaletteItem` component represents a color in the the `ColorPalette`.\n\n__Note:__ This is a UI5 Web Component! [ColorPaletteItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ColorPaletteItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the component is selected.\n\n**Note:** Only one item must be selected per <code>ui5-color-palette</code>.\nIf more than one item is defined as selected, the last one would be considered as the selected one.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the colour of the component.\n\n**Note:** The value should be a valid CSS color."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ColorPaletteItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ColorPalettePopover": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Represents a predefined range of colors for easier selection.\n\nOverview\nThe ColorPalettePopover provides the users with a slot to predefine colors.\n\nYou can customize them with the use of the colors property. You can specify a defaultColor and display a \"Default color\" button for the user to choose directly.\nYou can display a \"More colors...\" button that opens an additional color picker for the user to choose specific colors that are not present in the predefined range.\n\n### Usage\n\nThe palette is intended for users, who don't want to check and remember the different values of the colors and spend large amount of time to configure the right color through the color picker.\n\nFor the `ColorPalettePopover`\n\n\n__Note:__ This is a UI5 Web Component! [ColorPalettePopover UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ColorPalettePopover) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<IColorPaletteItem>`"
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ColorPalettePopoverDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `ColorPalettePopover` is closed due to user interaction.\n\n**Note:** Available since [v1.21.0](https://github.com/UI5/webcomponents/releases/tag/v1.21.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onItemClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ColorPalettePopoverDomRef, ColorPaletteItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user selects a color.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "color",
-                "type": "string",
-                "description": "the selected color"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
-        },
-        "defaultColor": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the default color of the component.\n\n**Note:** The default color should be a part of the ColorPalette colors`"
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the open | closed state of the popover.\n\n**Note:** Available since [v1.21.0](https://github.com/UI5/webcomponents/releases/tag/v1.21.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "opener": {
-          "type": {
-            "name": "string | HTMLElement"
-          },
-          "required": false,
-          "description": "Defines the ID or DOM Reference of the element that the popover is shown at.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript.\n\n**Note:** Available since [v1.21.0](https://github.com/UI5/webcomponents/releases/tag/v1.21.0) of **@ui5/webcomponents**."
-        },
-        "placement": {
-          "type": {
-            "name": "enum",
-            "raw": "PopoverPlacement | \"Start\" | \"End\" | \"Top\" | \"Bottom\"",
-            "value": [
-              {
-                "value": "\"Start\"",
-                "description": "Popover will be placed at the start of the reference element."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Popover will be placed at the end of the reference element."
-              },
-              {
-                "value": "\"Top\"",
-                "description": "Popover will be placed at the top of the reference element."
-              },
-              {
-                "value": "\"Bottom\"",
-                "description": "Popover will be placed at the bottom of the reference element."
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Top\""
-              },
-              {
-                "value": "\"Bottom\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines on which side the component is placed at.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Bottom\""
-          }
-        },
-        "showDefaultColor": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the user can choose the default color from a button.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showMoreColors": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the user can choose a custom color from a component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showRecentColors": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the user can see the last used colors in the bottom of the component",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ColorPalettePopoverDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ColorPicker": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ColorPicker` allows users to choose any color and provides different input options for selecting colors.\n\n### Usage\n\n#### When to use\nUse the color picker if:\n\n-  users need to select any color freely.\n\n#### When not to use\n\n-  Users need to select one color from a predefined set of colors. Use the ColorPalette component instead.\n\n\n\n__Note:__ This is a UI5 Web Component! [ColorPicker UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ColorPicker) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ColorPickerDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the the selected color is changed\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
-        },
-        "simplified": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "When set to `true`, the alpha slider and inputs for RGB values will not be displayed.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the currently selected color of the component.\n\n**Note**: use HEX, RGB, RGBA, HSV formats or a CSS color name when modifying this property.",
-          "defaultValue": {
-            "value": "\"rgba(255,255,255,1)\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ColorPickerDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ComboBox": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ComboBox` component represents a drop-down menu with a list of the available options and a text input field to narrow down the options.\n\nIt is commonly used to enable users to select an option from a predefined list.\n\n### Structure\nThe `ComboBox` consists of the following elements:\n\n-  Input field - displays the selected option or a custom user entry. Users can type to narrow down the list or enter their own value.\n-  Drop-down arrow - expands\\collapses the option list.\n-  Option list - the list of available options.\n\n### Working with Values\n\nThe ComboBox offers two ways to work with item selection:\n\n**1. Display Text Only (using `value`):**\n```html\n<ComboBox value=\"Germany\">\n  <ComboBoxItem text=\"Germany\"></ComboBoxItem>\n  <ComboBoxItem text=\"France\"></ComboBoxItem>\n</ComboBox>\n```\nUse this approach when the displayed text is sufficient for your needs.\n\n**2. Unique Identifiers - Recommended (using `selectedValue` and item `value`):**\n```html\n<ComboBox value=\"Germany\" selected-value=\"DE\">\n  <ComboBoxItem text=\"Germany\" value=\"DE\"></ComboBoxItem>\n  <ComboBoxItem text=\"France\" value=\"FR\"></ComboBoxItem>\n</ComboBox>\n```\nThis is the recommended approach when you need to work with unique identifiers (IDs, codes) separate from display text.\nThe `selectedValue` property references the `value` property of the selected item.\nIn forms, the item's `value` (e.g., \"DE\") will be submitted instead of the display text.\n\n**Important:** Do not mix the `selectedValue` approach with the deprecated `selected` property on items.\n\n### Keyboard Handling\n\nThe `ComboBox` provides advanced keyboard handling.\n\n- [F4], [Alt]+[Up], or [Alt]+[Down] - Toggles the picker.\n- [Escape] - Closes the picker, if open. If closed, cancels changes and reverts the typed in value.\n- [Enter] or [Return] - If picker is open, takes over the currently selected item and closes it.\n- [Down] - Selects the next matching item in the picker.\n- [Up] - Selects the previous matching item in the picker.\n- [Page Down] - Moves selection down by page size (10 items by default).\n- [Page Up] - Moves selection up by page size (10 items by default).\n- [Home] - If focus is in the ComboBox, moves cursor at the beginning of text. If focus is in the picker, selects the first item.\n- [End] - If focus is in the ComboBox, moves cursor at the end of text. If focus is in the picker, selects the last item.\n- [Ctrl]+[Alt]+[F8] or [Command]+[Option]+[F8] - Focuses the first link in the value state message, if available. Pressing [Tab] moves the focus to the next link in the value state message, or closes the value state message if there are no more links.\n\n\n\n__Note:__ This is a UI5 Web Component! [ComboBox UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ComboBox) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the component items.\n\n__Supported Node Type/s:__ `Array<IComboBoxItem>`"
-        },
-        "icon": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed in the input field.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
-        },
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the `ComboBox` is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ComboBoxDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter, focusout or an item is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ComboBoxDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the dropdown is closed.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ComboBoxDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when typing in input or clear icon is pressed.\n\n**Note:** filterValue property is updated, input is changed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ComboBoxDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the dropdown is opened.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ComboBoxDomRef, ComboBoxSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when selection is changed by user interaction\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "IComboBoxItem",
-                "description": "item to be selected."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component"
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "filter": {
-          "type": {
-            "name": "enum",
-            "raw": "ComboBoxFilter | \"StartsWithPerTerm\" | \"StartsWith\" | \"Contains\" | \"None\"",
-            "value": [
-              {
-                "value": "\"StartsWithPerTerm\"",
-                "description": "Defines filtering by first symbol of each word of item's text."
-              },
-              {
-                "value": "\"StartsWith\"",
-                "description": "Defines filtering by starting symbol of item's text."
-              },
-              {
-                "value": "\"Contains\"",
-                "description": "Defines contains filtering."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Removes any filtering applied while typing"
-              },
-              {
-                "value": "\"StartsWithPerTerm\""
-              },
-              {
-                "value": "\"StartsWith\""
-              },
-              {
-                "value": "\"Contains\""
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the filter type of the component.",
-          "defaultValue": {
-            "value": "\"StartsWithPerTerm\""
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether a loading indicator should be shown in the picker.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
-        },
-        "noTypeahead": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the value will be autocompleted to match an item\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the items picker is open.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selectedValue": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the selected item (references the `value` property of `ComboBoxItem`).\n\nUse this property to work with unique identifiers (IDs, codes) instead of display text.\nWhen set, the ComboBox finds and selects the item whose `value` property matches this property.\n\n**Benefits:**\n- Select items programmatically by their unique identifier\n- Handle items with identical display text but different underlying values\n- Submit machine-readable values in forms (the item's `value` is submitted instead of the display text)\n\n**When to use `selectedValue` vs `value`:**\n- **Recommended:** Use `selectedValue` + item `value` when you need unique identifiers separate from display text (e.g., country codes \"DE\", \"FR\" with display names \"Germany\", \"France\")\n- Use only the ComboBox `value` property when the display text itself is sufficient for your use case\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
-        },
-        "showClearIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the clear icon of the combobox will be shown.\n\n**Note:** Available since [v1.20.1](https://github.com/UI5/webcomponents/releases/tag/v1.20.1) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ComboBoxDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ComboBoxItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ComboBoxItem` represents the item for a `ComboBox`.\n\n__Note:__ This is a UI5 Web Component! [ComboBoxItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ComboBoxItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "additionalText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the additional text of the component."
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the component."
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the `ComboBoxItem`.\n\nUse this property to associate a unique identifier or machine-readable value with the item,\nseparate from the display text. This enables:\n- Selecting items programmatically via `selectedValue` on the ComboBox\n- Submitting machine-readable values in forms\n- Distinguishing between items with identical display text\n\n**When to use:**\n- **Recommended:** Use the `value` property on items together with `selectedValue` on the ComboBox when you need unique identifiers\n- Omit `value` if the display text (`text` property) is sufficient for your use case\n\n**Example:**\n```html\n<ComboBox selected-value=\"DE\">\n  <ComboBoxItem text=\"Germany\" value=\"DE\"></ComboBoxItem>\n  <ComboBoxItem text=\"France\" value=\"FR\"></ComboBoxItem>\n</ComboBox>\n```\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ComboBoxItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ComboBoxItemGroup": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ui5-cb-group-item` is type of suggestion item,\nthat can be used to split the `ComboBox` suggestions into groups.\n\n__Note:__ This is a UI5 Web Component! [ComboBoxItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ComboBoxItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the <code>ui5-cb-item-group</code>.\n\n__Supported Node Type/s:__ `Array<ComboBoxItem>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
-        },
-        "onMove": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ComboBoxItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMoveOver": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ComboBoxItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "headerAccessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the header."
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text of the <code>ui5-li-group</code>."
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "WrappingType | \"None\" | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ExpandableText` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ComboBoxItemGroupDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "header",
-          "description": "Used to style the header item of the group"
-        },
-        {
-          "name": "title",
-          "description": "Used to style the title of the group header"
-        }
-      ]
-    },
-    "DatePicker": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `DatePicker` component provides an input field with assigned calendar which opens on user action.\nThe `DatePicker` allows users to select a localized date using touch,\nmouse, or keyboard input. It consists of two parts: the date input field and the\ndate picker.\n\n### Usage\n\nThe user can enter a date by:\n\n- Using the calendar that opens in a popup\n- Typing it in directly in the input field\n\nWhen the user makes an entry and presses the enter key, the calendar shows the corresponding date.\nWhen the user directly triggers the calendar display, the actual date is displayed.\n\n### Formatting\n\nIf a date is entered by typing it into\nthe input field, it must fit to the used date format.\n\nSupported format options are pattern-based on Unicode LDML Date Format notation.\nFor more information, see [UTS #35: Unicode Locale Data Markup Language](https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table).\n\nFor example, if the valueFormat is \"yyyy-MM-dd\", the displayFormat is \"MMM d, y\", and the used locale is English, a valid value string is \"2015-07-30\", which leads to an output of \"Jul 30, 2015\".\nIf no placeholder is set to the DatePicker, the used displayFormat is displayed as a placeholder. If another placeholder is needed, it must be set.\n\n### Keyboard Handling\nThe `DatePicker` provides advanced keyboard handling.\nIf the `DatePicker` is focused,\nyou can open or close the drop-down by pressing [F4], [Alt] + [Up] or [Alt] + [Down] keys.\nOnce the drop-down is opened, you can use the [Up], [Down], [Left] or [Right] arrow keys\nto navigate through the dates and select one by pressing the `Space` or `Enter` keys. Moreover you can\nuse TAB to reach the buttons for changing month and year.\n\nIf the `DatePicker` input field is focused and its corresponding picker dialog is not opened,\nthen users can increment or decrement the date referenced by `dateValue` property\nby using the following shortcuts:\n\n- [Page Down] - Decrements the corresponding day of the month by one\n- [Shift] + [Page Down] - Decrements the corresponding month by one\n- [Shift] + [Ctrl] + [Page Down] - Decrements the corresponding year by one\n- [Page Up] - Increments the corresponding day of the month by one\n- [Shift] + [Page Up] - Increments the corresponding month by one\n- [Shift] + [Ctrl] + [Page Up] - Increments the corresponding year by one\n\n### Calendar types\nThe component supports several calendar types - Gregorian, Buddhist, Islamic, Japanese and Persian.\nBy default the Gregorian Calendar is used. In order to use the Buddhist, Islamic, Japanese or Persian calendar,\nyou need to set the `primaryCalendarType` property and import one or more of the following modules:\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Buddhist.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Islamic.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Japanese.js\";`\n\n`import \"@ui5/webcomponents-localization/dist/features/calendar/Persian.js\";`\n\nOr, you can use the global configuration and set the `calendarType` key:\n\n```html\n<script data-id=\"sap-ui-config\" type=\"application/json\">\n\t{\n\t\t\"calendarType\": \"Japanese\"\n\t}\n<script>\n```\n\n\n\n__Note:__ This is a UI5 Web Component! [DatePicker UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/DatePicker) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DatePickerDomRef, DatePickerChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in correct format pattern and in valid range."
-              },
-              {
-                "name": "value",
-                "type": "string",
-                "description": "The submitted value."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DatePickerDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component's picker is closed.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DatePickerDomRef, DatePickerInputEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the component is changed at each key stroke.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in correct format pattern and in valid range."
-              },
-              {
-                "name": "value",
-                "type": "string",
-                "description": "The submitted value."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DatePickerDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component's picker is opened.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onValueStateChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DatePickerDomRef, DatePickerValueStateChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the value state of the component is updated internally.\nThe event is preventable, meaning that if it's default action is\nprevented, the component will not update the value state.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in correct format pattern and in valid range."
-              },
-              {
-                "name": "valueState",
-                "type": "string",
-                "description": "The new `valueState` that will be set."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the aria-label attribute for the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component."
-        },
-        "calendarWeekNumbering": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarWeekNumbering | \"Default\" | \"ISO_8601\" | \"MiddleEastern\" | \"WesternTraditional\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "The default calendar week numbering:\n\nThe framework determines the week numbering scheme; currently it is derived from the\nactive format locale. Future versions of ui5-webcomponents might select a different week numbering\nscheme."
-              },
-              {
-                "value": "\"ISO_8601\"",
-                "description": "Official calendar week numbering in most of Europe (ISO 8601 standard):\nMonday is first day of the week, the week containing January 4th is first week of the year."
-              },
-              {
-                "value": "\"MiddleEastern\"",
-                "description": "Official calendar week numbering in much of the Middle East (Middle Eastern calendar):\nSaturday is first day of the week, the week containing January 1st is first week of the year."
-              },
-              {
-                "value": "\"WesternTraditional\"",
-                "description": "Official calendar week numbering in the United States, Canada, Brazil, Israel, Japan, and\nother countries (Western traditional calendar):\nSunday is first day of the week, the week containing January 1st is first week of the year."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"ISO_8601\""
-              },
-              {
-                "value": "\"MiddleEastern\""
-              },
-              {
-                "value": "\"WesternTraditional\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines how to calculate calendar weeks and first day of the week.\nIf not set, the calendar will be displayed according to the currently set global configuration.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is displayed as disabled.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "displayFormat": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, displayed in the input field.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "formatPattern": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, displayed in the input field.\n@deprecated Use displayFormat and valueFormat instead"
-        },
-        "hideWeekNumbers": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the visibility of the week numbers column.\n\n**Note:** For calendars other than Gregorian,\nthe week numbers are not displayed regardless of what is set.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "maxDate": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the maximum date available for selection.\n\n**Note:** If the formatPattern property is not set, the maxDate value must be provided in the ISO date format (yyyy-MM-dd)."
-        },
-        "minDate": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the minimum date available for selection.\n\n**Note:** If the formatPattern property is not set, the minDate value must be provided in the ISO date format (yyyy-MM-dd)."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the open or closed state of the popover.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint, intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** When no placeholder is set, the format pattern is displayed as a placeholder.\nPassing an empty string as the value of this property will make the component appear empty - without placeholder or format pattern."
-        },
-        "primaryCalendarType": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
-            "value": [
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              },
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Sets a calendar type used for display.\nIf not set, the calendar type of the global configuration is used."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is displayed as read-only.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "secondaryCalendarType": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
-            "value": [
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              },
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the secondary calendar type.\nIf not set, the calendar will only show the primary calendar type."
-        },
-        "showClearIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a formatted date value."
-        },
-        "valueFormat": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, used for the value attribute.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<DatePickerDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "formatValue",
-          "description": "Currently selected date represented as a Local JavaScript Date instance. Note: this getter can only be reliably used after the component is fully defined. Use dateValueAsync which resolves only when this condition is met. / readonly dateValue: Date | null; /** Promise that resolves to the currently selected date represented as a Local JavaScript Date instance. / readonly dateValueAsync: Promise<Date | null>; /** Formats a Java Script date object into a string representing a locale date according to the `formatPattern` property of the DatePicker instance",
-          "params": [
-            {
-              "name": "date",
-              "type": {
-                "name": "Date"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "string"
-          }
-        },
-        {
-          "name": "isInValidRange",
-          "description": "Checks if a date is between the minimum and maximum date.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        },
-        {
-          "name": "isValid",
-          "description": "Checks if a value is valid against the current date format of the DatePicker.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        },
-        {
-          "name": "isValidDisplayValue",
-          "description": "Checks if a value is valid against the current date format of the DatePicker.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        },
-        {
-          "name": "isValidValue",
-          "description": "Checks if a value is valid against the current date format of the DatePicker.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "input",
-          "description": "Used to style the input element. This part is forwarded to the underlying ui5-input element."
-        }
-      ]
-    },
-    "DateRangePicker": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The DateRangePicker enables the users to enter a localized date range using touch, mouse, keyboard input, or by selecting a date range in the calendar.\n\n### Usage\nThe user can enter a date by:\nUsing the calendar that opens in a popup or typing it in directly in the input field (not available for mobile devices).\nFor the `DateRangePicker`\n\n\n### Keyboard Handling\nThe `DateRangePicker` provides advanced keyboard handling.\n\nWhen the `DateRangePicker` input field is focused the user can\nincrement or decrement respectively the range start or end date, depending on where the cursor is.\nThe following shortcuts are available:\n\n- [Page Down] - Decrements the corresponding day of the month by one\n- [Shift] + [Page Down] - Decrements the corresponding month by one\n- [Shift] + [Ctrl] + [Page Down] - Decrements the corresponding year by one\n- [Page Up] - Increments the corresponding day of the month by one\n- [Shift] + [Page Up] - Increments the corresponding month by one\n- [Shift] + [Ctrl] + [Page Up] - Increments the corresponding year by one\n\n__Note:__ This is a UI5 Web Component! [DateRangePicker UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/DateRangePicker) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DateRangePickerDomRef, DatePickerChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in correct format pattern and in valid range."
-              },
-              {
-                "name": "value",
-                "type": "string",
-                "description": "The submitted value."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DateRangePickerDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component's picker is closed.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DateRangePickerDomRef, DatePickerInputEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the component is changed at each key stroke.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in correct format pattern and in valid range."
-              },
-              {
-                "name": "value",
-                "type": "string",
-                "description": "The submitted value."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DateRangePickerDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component's picker is opened.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onValueStateChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DateRangePickerDomRef, DatePickerValueStateChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the value state of the component is updated internally.\nThe event is preventable, meaning that if it's default action is\nprevented, the component will not update the value state.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in correct format pattern and in valid range."
-              },
-              {
-                "name": "valueState",
-                "type": "string",
-                "description": "The new `valueState` that will be set."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the aria-label attribute for the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component."
-        },
-        "calendarWeekNumbering": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarWeekNumbering | \"Default\" | \"ISO_8601\" | \"MiddleEastern\" | \"WesternTraditional\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "The default calendar week numbering:\n\nThe framework determines the week numbering scheme; currently it is derived from the\nactive format locale. Future versions of ui5-webcomponents might select a different week numbering\nscheme."
-              },
-              {
-                "value": "\"ISO_8601\"",
-                "description": "Official calendar week numbering in most of Europe (ISO 8601 standard):\nMonday is first day of the week, the week containing January 4th is first week of the year."
-              },
-              {
-                "value": "\"MiddleEastern\"",
-                "description": "Official calendar week numbering in much of the Middle East (Middle Eastern calendar):\nSaturday is first day of the week, the week containing January 1st is first week of the year."
-              },
-              {
-                "value": "\"WesternTraditional\"",
-                "description": "Official calendar week numbering in the United States, Canada, Brazil, Israel, Japan, and\nother countries (Western traditional calendar):\nSunday is first day of the week, the week containing January 1st is first week of the year."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"ISO_8601\""
-              },
-              {
-                "value": "\"MiddleEastern\""
-              },
-              {
-                "value": "\"WesternTraditional\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines how to calculate calendar weeks and first day of the week.\nIf not set, the calendar will be displayed according to the currently set global configuration.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "delimiter": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the symbol which separates the dates.\nIf not supplied, the default time interval delimiter for the current locale will be used.",
-          "defaultValue": {
-            "value": "\"-\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is displayed as disabled.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "displayFormat": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, displayed in the input field.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "formatPattern": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, displayed in the input field.\n@deprecated Use displayFormat and valueFormat instead"
-        },
-        "hideWeekNumbers": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the visibility of the week numbers column.\n\n**Note:** For calendars other than Gregorian,\nthe week numbers are not displayed regardless of what is set.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "maxDate": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the maximum date available for selection.\n\n**Note:** If the formatPattern property is not set, the maxDate value must be provided in the ISO date format (yyyy-MM-dd)."
-        },
-        "minDate": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the minimum date available for selection.\n\n**Note:** If the formatPattern property is not set, the minDate value must be provided in the ISO date format (yyyy-MM-dd)."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the open or closed state of the popover.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint, intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** When no placeholder is set, the format pattern is displayed as a placeholder.\nPassing an empty string as the value of this property will make the component appear empty - without placeholder or format pattern."
-        },
-        "primaryCalendarType": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
-            "value": [
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              },
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Sets a calendar type used for display.\nIf not set, the calendar type of the global configuration is used."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is displayed as read-only.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "secondaryCalendarType": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
-            "value": [
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              },
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the secondary calendar type.\nIf not set, the calendar will only show the primary calendar type."
-        },
-        "showClearIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a formatted date value."
-        },
-        "valueFormat": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, used for the value attribute.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<DateRangePickerDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "formatValue",
-          "description": "**Note:** The getter method is inherited and not supported. If called it will return an empty value. / readonly dateValue: Date | null; /** Promise that resolves to the currently selected date represented as a Local JavaScript Date instance. / readonly dateValueAsync: Promise<Date | null>; /** **Note:** The getter method is inherited and not supported. If called it will return an empty value. / readonly dateValueUTC: Date | null; /** Returns the end date of the currently selected range as JavaScript Date instance. / readonly endDateValue: Date | null; /** Formats a Java Script date object into a string representing a locale date according to the `formatPattern` property of the DatePicker instance",
-          "params": [
-            {
-              "name": "date",
-              "type": {
-                "name": "Date"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "string"
-          }
-        },
-        {
-          "name": "isInValidRange",
-          "description": "Checks if a date is between the minimum and maximum date.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        },
-        {
-          "name": "isValid",
-          "description": "Checks if a value is valid against the current date format of the DatePicker.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        },
-        {
-          "name": "isValidDisplayValue",
-          "description": "Checks if a value is valid against the current date format of the DatePicker.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        },
-        {
-          "name": "isValidValue",
-          "description": "Checks if a value is valid against the current date format of the DatePicker.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "input",
-          "description": "Used to style the input element. This part is forwarded to the underlying ui5-input element."
-        }
-      ]
-    },
-    "DateTimePicker": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `DateTimePicker` component alows users to select both date (day, month and year) and time (hours, minutes and seconds)\nand for the purpose it consists of input field and Date/Time picker.\n\n### Usage\n\nUse the `DateTimePicker` if you need a combined date and time input component.\nDon't use it if you want to use either date, or time value.\nIn this case, use the `DatePicker` or the `TimePicker` components instead.\n\nThe user can set date/time by:\n\n- using the calendar and the time selectors\n- typing in the input field\n\nProgrammatically, to set date/time for the `DateTimePicker`, use the `value` property\n\n### Formatting\n\nThe value entered by typing into the input field must fit to the used date/time format.\n\nSupported format options are pattern-based on Unicode LDML Date Format notation.\nFor more information, see [UTS #35: Unicode Locale Data Markup Language](https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table).\n\n**Example:** the following format `dd/MM/yyyy, hh:mm:ss aa`\ncorresponds the `13/04/2020, 03:16:16 AM` value.\n\nThe small 'h' defines \"12\" hours format and the \"aa\" symbols - \"AM/PM\" time periods.\n\n**Example:** the following format `dd/MM/yyyy, HH:mm:ss`\ncorresponds the `13/04/2020, 15:16:16` value.\n\nThe capital 'H' indicates \"24\" hours format.\n\n**Note:** If the `formatPattern` does NOT include time,\nthe `DateTimePicker` will fallback to the default time format according to the locale.\n\n**Note:** If no placeholder is set to the `DateTimePicker`,\nthe current `formatPattern` is displayed as a placeholder.\nIf another placeholder is needed, it must be set or in case no placeholder is needed - it can be set to an empty string.\n\n**Note:** If the user input does NOT match the `formatPattern`,\nthe `DateTimePicker` makes an attempt to parse it based on the\nlocale settings.\n\n### Responsive behavior\n\nThe `DateTimePicker` is responsive and fully adapts to all devices.\nFor larger screens, such as tablet or desktop, it is displayed as a popover, while\non phone devices, it is displayed full screen.\n\n\n\n__Note:__ This is a UI5 Web Component! [DateTimePicker UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/DateTimePicker) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DateTimePickerDomRef, DatePickerChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in correct format pattern and in valid range."
-              },
-              {
-                "name": "value",
-                "type": "string",
-                "description": "The submitted value."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DateTimePickerDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component's picker is closed.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DateTimePickerDomRef, DatePickerInputEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the component is changed at each key stroke.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in correct format pattern and in valid range."
-              },
-              {
-                "name": "value",
-                "type": "string",
-                "description": "The submitted value."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DateTimePickerDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component's picker is opened.\n\n**Note:** Available since [v2.4.0](https://github.com/UI5/webcomponents/releases/tag/v2.4.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onValueStateChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DateTimePickerDomRef, DatePickerValueStateChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the value state of the component is updated internally.\nThe event is preventable, meaning that if it's default action is\nprevented, the component will not update the value state.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in correct format pattern and in valid range."
-              },
-              {
-                "name": "valueState",
-                "type": "string",
-                "description": "The new `valueState` that will be set."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the aria-label attribute for the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component."
-        },
-        "calendarWeekNumbering": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarWeekNumbering | \"Default\" | \"ISO_8601\" | \"MiddleEastern\" | \"WesternTraditional\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "The default calendar week numbering:\n\nThe framework determines the week numbering scheme; currently it is derived from the\nactive format locale. Future versions of ui5-webcomponents might select a different week numbering\nscheme."
-              },
-              {
-                "value": "\"ISO_8601\"",
-                "description": "Official calendar week numbering in most of Europe (ISO 8601 standard):\nMonday is first day of the week, the week containing January 4th is first week of the year."
-              },
-              {
-                "value": "\"MiddleEastern\"",
-                "description": "Official calendar week numbering in much of the Middle East (Middle Eastern calendar):\nSaturday is first day of the week, the week containing January 1st is first week of the year."
-              },
-              {
-                "value": "\"WesternTraditional\"",
-                "description": "Official calendar week numbering in the United States, Canada, Brazil, Israel, Japan, and\nother countries (Western traditional calendar):\nSunday is first day of the week, the week containing January 1st is first week of the year."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"ISO_8601\""
-              },
-              {
-                "value": "\"MiddleEastern\""
-              },
-              {
-                "value": "\"WesternTraditional\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines how to calculate calendar weeks and first day of the week.\nIf not set, the calendar will be displayed according to the currently set global configuration.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is displayed as disabled.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "displayFormat": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, displayed in the input field.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "formatPattern": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, displayed in the input field.\n@deprecated Use displayFormat and valueFormat instead"
-        },
-        "hideWeekNumbers": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the visibility of the week numbers column.\n\n**Note:** For calendars other than Gregorian,\nthe week numbers are not displayed regardless of what is set.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "maxDate": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the maximum date available for selection.\n\n**Note:** If the formatPattern property is not set, the maxDate value must be provided in the ISO date format (yyyy-MM-dd)."
-        },
-        "minDate": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the minimum date available for selection.\n\n**Note:** If the formatPattern property is not set, the minDate value must be provided in the ISO date format (yyyy-MM-dd)."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the open or closed state of the popover.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint, intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** When no placeholder is set, the format pattern is displayed as a placeholder.\nPassing an empty string as the value of this property will make the component appear empty - without placeholder or format pattern."
-        },
-        "primaryCalendarType": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
-            "value": [
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              },
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Sets a calendar type used for display.\nIf not set, the calendar type of the global configuration is used."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is displayed as read-only.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "secondaryCalendarType": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarType | \"Gregorian\" | \"Islamic\" | \"Japanese\" | \"Buddhist\" | \"Persian\"",
-            "value": [
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              },
-              {
-                "value": "\"Gregorian\""
-              },
-              {
-                "value": "\"Islamic\""
-              },
-              {
-                "value": "\"Japanese\""
-              },
-              {
-                "value": "\"Buddhist\""
-              },
-              {
-                "value": "\"Persian\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the secondary calendar type.\nIf not set, the calendar will only show the primary calendar type."
-        },
-        "showClearIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a formatted date value."
-        },
-        "valueFormat": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, used for the value attribute.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<DateTimePickerDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "formatValue",
-          "description": "Currently selected date represented as a Local JavaScript Date instance. Note: this getter can only be reliably used after the component is fully defined. Use dateValueAsync which resolves only when this condition is met. / readonly dateValue: Date | null; /** Promise that resolves to the currently selected date represented as a Local JavaScript Date instance. / readonly dateValueAsync: Promise<Date | null>; /** Formats a Java Script date object into a string representing a locale date according to the `formatPattern` property of the DatePicker instance",
-          "params": [
-            {
-              "name": "date",
-              "type": {
-                "name": "Date"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "string"
-          }
-        },
-        {
-          "name": "isInValidRange",
-          "description": "Checks if a date is between the minimum and maximum date.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        },
-        {
-          "name": "isValid",
-          "description": "Checks if a value is valid against the current date format of the DatePicker.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        },
-        {
-          "name": "isValidDisplayValue",
-          "description": "Checks if a value is valid against the current date format of the DatePicker.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        },
-        {
-          "name": "isValidValue",
-          "description": "Checks if a value is valid against the current date format of the DatePicker.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "input",
-          "description": "Used to style the input element. This part is forwarded to the underlying ui5-input element."
-        }
-      ]
-    },
-    "Dialog": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Dialog` component is used to temporarily display some information in a\nsize-limited window in front of the regular app screen.\nIt is used to prompt the user for an action or a confirmation.\nThe `Dialog` interrupts the current app processing as it is the only focused UI element and\nthe main screen is dimmed/blocked.\nThe dialog combines concepts known from other technologies where the windows have\nnames such as dialog box, dialog window, pop-up, pop-up window, alert box, or message box.\n\nThe `Dialog` is modal, which means that a user action is required before it is possible to return to the parent window.\nTo open multiple dialogs, each dialog element should be separate in the markup. This will ensure the correct modal behavior. Avoid nesting dialogs within each other.\nThe content of the `Dialog` is fully customizable.\n\n### Structure\nA `Dialog` consists of a header, content, and a footer for action buttons.\nThe `Dialog` is usually displayed at the center of the screen.\nIts position can be changed by the user. To enable this, you need to set the property `draggable` accordingly.\n\n\n### Responsive Behavior\nThe `stretch` property can be used to stretch the `Dialog` to full screen. For better usability, it's recommended to stretch the dialog to full screen on phone devices.\n\n**Note:** When a `Bar` is used in the header or in the footer, you should remove the default dialog's paddings.\n\nFor more information see the sample \"Bar in Header/Footer\".\n\n### Keyboard Handling\n\n#### Basic Navigation\nWhen the `Dialog` has the `draggable` property set to `true` and the header is focused, the user can move the dialog\nwith the following keyboard shortcuts:\n\n- [Up] or [Down] arrow keys - Move the dialog up/down.\n- [Left] or [Right] arrow keys - Move the dialog left/right.\n\n#### Resizing\nWhen the `Dialog` has the `resizable` property set to `true` and the header is focused, the user can change the size of the dialog\nwith the following keyboard shortcuts:\n\n- [Shift] + [Up] or [Down] - Decrease/Increase the height of the dialog.\n- [Shift] + [Left] or [Right] - Decrease/Increase the width of the dialog.\n\n\n\n__Note:__ This is a UI5 Web Component! [Dialog UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Dialog) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the Popup.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "footer": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the footer HTML Element.\n\n**Note:** When a `Bar` is used in the footer, you should remove the default dialog's paddings.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header HTML Element.\n\n**Note:** When a `Bar` is used in the header, you should remove the default dialog's paddings.\n\n**Note:** If `header` slot is provided, the labelling of the dialog is a responsibility of the application developer.\n`accessibleName` should be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onBeforeClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, PopupBeforeCloseEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "escPressed",
-                "type": "boolean",
-                "description": "Indicates that `ESC` key has triggered the event."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onBeforeOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "PopupAccessibleRole | \"None\" | \"Dialog\" | \"AlertDialog\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "Represents no ARIA role."
-              },
-              {
-                "value": "\"Dialog\"",
-                "description": "Represents the ARIA role \"dialog\"."
-              },
-              {
-                "value": "\"AlertDialog\"",
-                "description": "Represents the ARIA role \"alertdialog\"."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Dialog\""
-              },
-              {
-                "value": "\"AlertDialog\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Dialog\""
-          }
-        },
-        "draggable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is draggable.\nIf this property is set to true, the Dialog will be draggable by its header.\n\n**Note:** The component can be draggable only in desktop mode.\n\n**Note:** This property overrides the default HTML \"draggable\" attribute native behavior.\nWhen \"draggable\" is set to true, the native browser \"draggable\"\nbehavior is prevented and only the Dialog custom logic (\"draggable by its header\") works.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text.\n\n**Note:** If `header` slot is provided, the `headerText` is ignored."
-        },
-        "initialFocus": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the ID of the HTML Element, which will get the initial focus.\n\n**Note:** If an element with `autofocus` attribute is added inside the component,\n`initialFocus` won't take effect."
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if the element is open\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "preventFocusRestore": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "preventInitialFocus": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "resizable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Configures the component to be resizable.\nIf this property is set to true, the Dialog will have a resize handle in its bottom right corner in LTR languages.\nIn RTL languages, the resize handle will be placed in the bottom left corner.\n\n**Note:** The component can be resizable only in desktop mode.\n\n**Note:** Upon resizing, externally defined height and width styling will be ignored.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "state": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the state of the `Dialog`.\n\n**Note:** If `\"Negative\"` and `\"Critical\"` states is set, it will change the\naccessibility role to \"alertdialog\", if the accessibleRole property is set to `\"Dialog\"`.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "stretch": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines if the dialog will be stretched to full screen on mobile. On desktop,\nthe dialog will be stretched to approximately 90% of the viewport.\n\n**Note:** For better usability of the component it is recommended to set this property to \"true\" when the dialog is opened on phone.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<DialogDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "applyFocus",
-          "description": "Focuses the element denoted by `initialFocus`, if provided, or the first focusable element otherwise.",
-          "params": [],
-          "returns": {
-            "type": "Promise<void>"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "content",
-          "description": "Used to style the content of the component"
-        },
-        {
-          "name": "footer",
-          "description": "Used to style the footer of the component"
-        },
-        {
-          "name": "header",
-          "description": "Used to style the header of the component"
-        }
-      ]
-    },
-    "DynamicDateRange": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `DynamicDateRange` component provides a flexible interface to define date ranges using a combination of absolute dates, relative intervals, and preset ranges (e.g., \"Today\", \"Yesterday\", etc.).\nIt allows users to select a date range from a predefined set of options or enter custom dates.\n\n### Usage\n\nThe component is typically used in scenarios where users need to filter data based on date ranges, such as in reports, dashboards, or data analysis tools.\nIt can be used with the predefined options or extended with custom options to suit specific requirements. You can create your own options by extending the `IDynamicDateRangeOption` interface.\nEvery option should be registered using the `DynamicDateRange.register` method.\n\nIf needed, you can also create a range of dates based on specific option using the `toDates` method.\n\n### Standard Options\n\nThe component comes with a set of standard options, including:\n- \"TODAY\" - Represents the current date. An example value is `{ operator: \"TODAY\"}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/Today.js\";`\n- \"YESTERDAY\" - Represents the previous date. An example value is `{ operator: \"YESTERDAY\"}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/Yesterday.js\";`\n- \"TOMORROW\" - Represents the next date. An example value is `{ operator: \"TOMORROW\"}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/Tomorrow.js\";`\n- \"DATE\" - Represents a single date. An example value is `{ operator: \"DATE\", values: [new Date()]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/SingleDate.js\";`\n- \"DATERANGE\" - Represents a range of dates. An example value is `{ operator: \"DATERANGE\", values: [new Date(), new Date()]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/DateRange.js\";`\n- \"DATETIMERANGE\" - Represents a range of dates with times. An example value is `{ operator: \"DATETIMERANGE\", values: [new Date(), new Date()]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/DateTimeRange.js\";`\n- \"FROMDATETIME\" - Represents a range from date and time. An example value is `{ operator: \"FROMDATETIME\", values: [new Date()]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/FromDateTime.js\";`\n- \"TODATETIME\" - Represents a range to date and time. An example value is `{ operator: \"TODATETIME\", values: [new Date()]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/ToDateTime.js\";`\n- \"LASTDAYS\" - Represents Last X Days from today. An example value is `{ operator: \"LASTDAYS\", values: [2]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/LastOptions.js\";`\n- \"LASTWEEKS\" - Represents Last X Weeks from today. An example value is `{ operator: \"LASTWEEKS\", values: [3]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/LastOptions.js\";`\n- \"LASTMONTHS\" - Represents Last X Months from today. An example value is `{ operator: \"LASTMONTHS\", values: [6]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/LastOptions.js\";`\n- \"LASTQUARTERS\" - Represents Last X Quarters from today. An example value is `{ operator: \"LASTQUARTERS\", values: [2]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/LastOptions.js\";`\n- \"LASTYEARS\" - Represents Last X Years from today. An example value is `{ operator: \"LASTYEARS\", values: [1]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/LastOptions.js\";`\n- \"NEXTDAYS\" - Represents Next X Days from today. An example value is `{ operator: \"NEXTDAYS\", values: [2]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/NextOptions.js\";`\n- \"NEXTWEEKS\" - Represents Next X Weeks from today. An example value is `{ operator: \"NEXTWEEKS\", values: [3]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/NextOptions.js\";`\n- \"NEXTMONTHS\" - Represents Next X Months from today. An example value is `{ operator: \"NEXTMONTHS\", values: [6]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/NextOptions.js\";`\n- \"NEXTQUARTERS\" - Represents Next X Quarters from today. An example value is `{ operator: \"NEXTQUARTERS\", values: [2]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/NextOptions.js\";`\n- \"NEXTYEARS\" - Represents Next X Years from today. An example value is `{ operator: \"NEXTYEARS\", values: [1]}`. Import: `import \"@ui5/webcomponents/dist/dynamic-date-range-options/NextOptions.js\";`\n\n\n\n__Note:__ This is a UI5 Web Component! [DynamicDateRange UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/DynamicDateRange) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DynamicDateRangeDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter or on focusout or a value is selected in the popover.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "options": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the options listed as a string, separated by commas and using capital case.\nExample: \"TODAY, YESTERDAY, DATERANGE\""
-        },
-        "value": {
-          "type": {
-            "name": "DynamicDateRangeValue"
-          },
-          "required": false,
-          "description": "Defines the value object."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<DynamicDateRangeDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "toDates",
-          "description": "Converts a `value` into concrete `startDate` and `endDate` JavaScript `Date` objects.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "DynamicDateRangeValue"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "Array<Date>"
-          }
-        }
-      ]
-    },
-    "DynamicPage": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A layout component, representing a web page, consisting of a title, header with dynamic behavior, a content area, and an optional floating footer.\n\nThe component consist of several components:\n\n- `DynamicPageTitle` - a component, holding the title of the page, the navigation actions and the content. The displayed content changes based on the current mode of the `DynamicPageHeader`.\n- `DynamicPageHeader` - a generic container, which can contain a single layout component and any other HTML elements. The header works in two modes - expanded and snapped and its behavior can be adjusted with the help of different properties.\n- `Content area` - a generic container, which can have a single UI5 layout.\n- `Footer` - positioned at the bottom with a small offset and used for additional actions, the footer floats above the content.\n\n### Usage\n\nUse the `DynamicPage` if you need to have a title, that is always visible\nand a header, that has configurable Expanding/Snapping functionality.\nIf you don't need the Expanding/Snapping functionality it is better to use the\n`Page` as a lighter component.\n\nThe app can add to the `default` slot of the ui5-dynamic-page either content that is designed to fit its container (e.g. has 100% height),\nor content with own height that may overflow its container. In the second case the `DynamicPage` will show a scrollbar that allows the user\nscroll through the content.\n\n## Notes:\n\n- Snapping of the `DynamicPageTitle` is not supported in the following case:\n - When the `DynamicPage` has a scroll bar, the component usually scrolls to the snapping point - the point, where the `DynamicPageHeader` is scrolled out completely. However, when there is a scroll bar, but not enough content to reach the snapping point, the snapping is not possible using scrolling.\n\n### Responsive Behavior\n\nDynamic page web component implements the responsive paddings design.\n\n### Keyboard Handling\n\n\n### Basic Navigation\n\n- [SPACE, ENTER, RETURN] - If focus is on a button inside DynamicPageTitle its action is being triggered, once activated.\nIf focus is on the snap header button (arrow button), or on the header itself, once activated, it triggers the associated action (such as snap/expand the header).\nIf focus is on pin button (the button with pin icon on the bottom of the header), once activated, it triggers the associated action (pinning of the header).\n\n### Fast Navigation\n- This component provides a build in fast navigation group which can be used via `F6 / Shift + F6` or ` Ctrl + Alt(Option) + Down /  Ctrl + Alt(Option) + Up`.\nIn order to use this functionality, you need to import the following module:\n\n- `import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [DynamicPage UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/DynamicPage) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the Dynamic Page.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "footerArea": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the footer HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footerArea\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "headerArea": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"headerArea\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<DynamicPageHeader>`"
-        },
-        "titleArea": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the title HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"titleArea\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<DynamicPageTitle>`"
-        },
-        "onPinButtonToggle": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DynamicPageDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the pin header button is toggled.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onTitleToggle": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DynamicPageDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the expand/collapse area of the title is toggled.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "headerPinned": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the header is pinned.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "headerSnapped": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the header is snapped.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hidePinButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the pin button is hidden.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showFooter": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the footer is shown.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<DynamicPageDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "content",
-          "description": "Used to style the content of the component"
-        },
-        {
-          "name": "fit-content",
-          "description": "Used to style the fit content container of the component."
-        },
-        {
-          "name": "footer",
-          "description": "Used to style the footer of the component"
-        }
-      ]
-    },
-    "DynamicPageHeader": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Header of the DynamicPage.\n\nThe DynamicPageHeader `DynamicPageHeader` is part of the DynamicPage family\nand is used to serve as header of the `DynamicPage`.\n\n### Usage\n\nThe `DynamicPageHeader` can hold any layout control and has two states - expanded\nand collapsed (snapped). The switching between these states happens when:\n- the user scrolls below its bottom margin\n- the user clicks on the `DynamicPageTitle`\n- through the `DynamicPage` property `headerSnapped`\n\n### Responsive Behavior\n\nThe responsive behavior of the `DynamicPageHeader` depends on the behavior of the\ncontent that is displayed.\n\n### Accessibility\n\nThe `DynamicPageHeader` provides an accessible label for the header region.\n\n__Note:__ This is a UI5 Web Component! [DynamicPageHeader UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/DynamicPageHeader) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the Dynamic Page Header.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<DynamicPageHeaderDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "DynamicPageTitle": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Title of the `DynamicPage`.\n\nThe `DynamicPageTitle` component is part of the `DynamicPage`\nfamily and is used to serve as title of the `DynamicPage`.\n\n### Usage\n\nThe `DynamicPageTitle` can hold any component and displays the most important\ninformation regarding the object that will always remain visible while scrolling.\n\n**Note:** The `actions` slot accepts any UI5 web component, but it's\nrecommended to use `ui5-toolbar`.\n\nThe user can switch between the expanded/collapsed states of the\n`DynamicPage` by clicking on the `DynamicPageTitle`\nor by using the expand/collapse visual indicators, positioned at the bottom of the\n`DynamicPageTitle` and the `DynamicPageHeader` inside `DynamicPageHeaderActions`.\n\n### Responsive Behavior\n\nThe responsive behavior of the `DynamicPageTitle` depends on the behavior of the\ncontent that is displayed.\n\n__Note:__ This is a UI5 Web Component! [DynamicPageTitle UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/DynamicPageTitle) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "actionsBar": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the bar with actions in the Dynamic page title.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"actionsBar\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "breadcrumbs": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content of the breadcrumbs inside Dynamic Page Title.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"breadcrumbs\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the Dynamic page title.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "heading": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content of the Heading of the Dynamic Page.\n\nThe font size of the title within the `heading` slot can be adjusted to the recommended values using the following CSS variables:\n\n**Expanded:** `var(--sapObjectHeader_Title_FontSize)`\n\n**Collapsed:** `var(--sapObjectHeader_Title_SnappedFontSize)`\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"heading\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "navigationBar": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the bar with navigation actions in the Dynamic page title.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"navigationBar\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<Toolbar>`"
-        },
-        "snappedHeading": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the heading that is shown only when the header is snapped.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"snappedHeading\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "snappedSubheading": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content of the title that is shown only when the header is snapped.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"snappedSubheading\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "snappedTitleOnMobile": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content of the snapped title on mobile devices.\n\nThis slot is displayed only when the `DynamicPageTitle` is in the snapped state on mobile devices.\nIt should be used to provide a simplified, single-line title that takes up less space on smaller screens.\n\n**Note:**\n- The content set in this slot **overrides** all other content set in the `DynamicPageTitle` slots when displayed.\n- The slot is intended for a single `ui5-title` component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"snappedTitleOnMobile\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.3.0](https://github.com/UI5/webcomponents/releases/tag/v2.3.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<Title>`"
-        },
-        "subheading": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content of the title that is shown only when the header is not snapped.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"subheading\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<DynamicPageTitleDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "DynamicSideContent": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The DynamicSideContent (`DynamicSideContent`) is a layout component that allows additional content\nto be displayed in a way that flexibly adapts to different screen sizes. The side\ncontent appears in a container next to or directly below the main content\n(it doesn't overlay). When the side content is triggered, the main content becomes\nnarrower (if appearing side-by-side). The side content contains a separate scrollbar\nwhen appearing next to the main content.\n\n### Usage\n\n*When to use?*\n\nUse this component if you want to display relevant information that is not critical\nfor users to complete a task. Users should have access to all the key functions and\ncritical information in the app even if they do not see the side content. This is\nimportant because on smaller screen sizes it may be difficult to display the side\ncontent in a way that is easily accessible for the user.\n\n*When not to use?*\n\nDon't use it if you want to display navigation or critical information that prevents\nusers from completing a task when they have no access to the side content.\n\n### Responsive Behavior\n\nScreen width \\> 1440px\n\n- Main vs. side content ratio is 75 vs. 25 percent (with a minimum of 320px\neach).\n- If the application defines a trigger, the side content can be hidden.\n\nScreen width \\<\\= 1440px and \\> 1024px\n\n- Main vs. side content ratio is 66.666 vs. 33.333 percent (with a minimum of\n320px each). If the side content width falls below 320 px, it automatically slides\nunder the main content, unless the app development team specifies that it should\ndisappear.\n\nScreen width \\<\\= 1024px and \\> 720px\n\n- The side content ratio is fixed to 340px, and the main content takes the rest\nof the width. Only if the `sideContentFallDown` is set to `OnMinimumWidth`\nand screen width is \\<\\= 960px and \\> 720px the side content falls below the main content.\n\nScreen width \\<\\= 720px (for example on a mobile device)\n\n- In this case, the side content automatically disappears from the screen (unless\nspecified to stay under the content by setting of `sideContentVisibility`\nproperty to `AlwaysShow`) and can be triggered from a pre-set trigger\n(specified within the app). When the side content is triggered, it replaces the main\ncontent. We recommend that you always place the trigger for the side content in the\nsame location, such as in the app footer.\n\nA special case allows switching the comparison mode between the main and side content.\nIn this case, the screen is split into 50:50 percent for main vs. side content. The\nresponsive behavior of the equal split is the same as in the standard view - the\nside content disappears on screen widths of less than 720 px and can only be\nviewed by triggering it.\n\n\n\n__Note:__ This is a UI5 Web Component! [DynamicSideContent UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/DynamicSideContent) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the main content.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "sideContent": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the side content.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"sideContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onLayoutChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<DynamicSideContentDomRef, DynamicSideContentLayoutChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fires when the current breakpoint has been changed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "currentBreakpoint",
-                "type": "string",
-                "description": "the current breakpoint."
-              },
-              {
-                "name": "mainContentVisible",
-                "type": "boolean",
-                "description": "visibility of the main content."
-              },
-              {
-                "name": "previousBreakpoint",
-                "type": "string | undefined",
-                "description": "the breakpoint that was active before change to current breakpoint."
-              },
-              {
-                "name": "sideContentVisible",
-                "type": "boolean",
-                "description": "visibility of the side content."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "DynamicSideContentAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines additional accessibility attributes on different areas of the component.\n\nThe accessibilityAttributes object has the following fields:\n\n - **mainContent**: `mainContent.ariaLabel` defines the aria-label of the main content area. Accepts any string.\n - **sideContent**: `sideContent.ariaLabel` defines the aria-label of the side content area. Accepts any string.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "equalSplit": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in equal split mode. In this mode, the side and\nthe main content take 50:50 percent of the container on all screen sizes\nexcept for phone, where the main and side contents are switching visibility\nusing the toggle method.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideMainContent": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the visibility of the main content.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideSideContent": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the visibility of the side content.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "sideContentFallDown": {
-          "type": {
-            "name": "enum",
-            "raw": "SideContentFallDown | \"BelowXL\" | \"BelowL\" | \"BelowM\" | \"OnMinimumWidth\"",
-            "value": [
-              {
-                "value": "\"BelowXL\"",
-                "description": "Side content falls down on breakpoints below XL"
-              },
-              {
-                "value": "\"BelowL\"",
-                "description": "Side content falls down on breakpoints below L"
-              },
-              {
-                "value": "\"BelowM\"",
-                "description": "Side content falls down on breakpoints below M"
-              },
-              {
-                "value": "\"OnMinimumWidth\"",
-                "description": "Side content falls down on breakpoint M and the minimum width for the side content"
-              },
-              {
-                "value": "\"BelowXL\""
-              },
-              {
-                "value": "\"BelowL\""
-              },
-              {
-                "value": "\"BelowM\""
-              },
-              {
-                "value": "\"OnMinimumWidth\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines on which breakpoints the side content falls down below the main content.",
-          "defaultValue": {
-            "value": "\"OnMinimumWidth\""
-          }
-        },
-        "sideContentPosition": {
-          "type": {
-            "name": "enum",
-            "raw": "SideContentPosition | \"End\" | \"Start\"",
-            "value": [
-              {
-                "value": "\"End\"",
-                "description": "The side content is on the right side of the main container\nin left-to-right mode and on the left side in right-to-left mode."
-              },
-              {
-                "value": "\"Start\"",
-                "description": "The side content is on the left side of the main container\nin left-to-right mode and on the right side in right-to-left mode."
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Start\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines whether the side content is positioned before the main content (left side\nin LTR mode), or after the the main content (right side in LTR mode).",
-          "defaultValue": {
-            "value": "\"End\""
-          }
-        },
-        "sideContentVisibility": {
-          "type": {
-            "name": "enum",
-            "raw": "SideContentVisibility | \"AlwaysShow\" | \"ShowAboveL\" | \"ShowAboveM\" | \"ShowAboveS\" | \"NeverShow\"",
-            "value": [
-              {
-                "value": "\"AlwaysShow\"",
-                "description": "Show the side content on any breakpoint"
-              },
-              {
-                "value": "\"ShowAboveL\"",
-                "description": "Show the side content on XL breakpoint"
-              },
-              {
-                "value": "\"ShowAboveM\"",
-                "description": "Show the side content on L and XL breakpoints"
-              },
-              {
-                "value": "\"ShowAboveS\"",
-                "description": "Show the side content on M, L and XL breakpoints"
-              },
-              {
-                "value": "\"NeverShow\"",
-                "description": "Don't show the side content on any breakpoints"
-              },
-              {
-                "value": "\"AlwaysShow\""
-              },
-              {
-                "value": "\"ShowAboveL\""
-              },
-              {
-                "value": "\"ShowAboveM\""
-              },
-              {
-                "value": "\"ShowAboveS\""
-              },
-              {
-                "value": "\"NeverShow\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines on which breakpoints the side content is visible.",
-          "defaultValue": {
-            "value": "\"ShowAboveS\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<DynamicSideContentDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "toggleContents",
-          "description": "Toggles visibility of main and side contents on S screen size (mobile device).",
-          "params": [],
-          "returns": {
-            "type": "void"
-          }
-        }
-      ]
-    },
-    "ExpandableText": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ExpandableText` component allows displaying a large body of text in a small space. It provides an \"expand/collapse\" functionality, which shows/hides potentially truncated text.\n\n### Usage\n\n#### When to use:\n- To accommodate long texts in limited space, for example in list items, table cell texts, or forms\n\n#### When not to use:\n- The content is critical for the user. In this case use short descriptions that can fit in\n- Strive to provide short and meaningful texts to avoid excessive number of \"Show More\" links on the page\n\n### Responsive Behavior\n\nOn phones, if the component is configured to display the full text in a popover, the popover will appear in full screen.\n\n__Note:__ For compatibility reasons, `children`, `showOverflowInPopover`, and `renderWhitespace` are added by the UI5 Web Components for React wrapper and are not part of the underlying web component (`ui5-expandable-text`).\nThese props will be removed in the next major release (not yet planned); see their deprecation notices for alternatives.\n\n__Note:__ This is a UI5 Web Component! [ExpandableText UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ExpandableText) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "emptyIndicatorMode": {
-          "type": {
-            "name": "enum",
-            "raw": "TextEmptyIndicatorMode | \"Off\" | \"On\"",
-            "value": [
-              {
-                "value": "\"Off\"",
-                "description": "Empty indicator is never rendered."
-              },
-              {
-                "value": "\"On\"",
-                "description": "Empty indicator is rendered always when the component's content is empty."
-              },
-              {
-                "value": "\"Off\""
-              },
-              {
-                "value": "\"On\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Specifies if an empty indicator should be displayed when there is no text.",
-          "defaultValue": {
-            "value": "\"Off\""
-          }
-        },
-        "maxCharacters": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Maximum number of characters to be displayed initially. If the text length exceeds this limit, the text will be truncated with an ellipsis, and the \"More\" link will be displayed.",
-          "defaultValue": {
-            "value": "100"
-          }
-        },
-        "overflowMode": {
-          "type": {
-            "name": "enum",
-            "raw": "ExpandableTextOverflowMode | \"InPlace\" | \"Popover\"",
-            "value": [
-              {
-                "value": "\"InPlace\"",
-                "description": "Overflowing text is appended in-place."
-              },
-              {
-                "value": "\"Popover\"",
-                "description": "Full text is displayed in a popover."
-              },
-              {
-                "value": "\"InPlace\""
-              },
-              {
-                "value": "\"Popover\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines how the full text will be displayed.",
-          "defaultValue": {
-            "value": "\"InPlace\""
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Text of the component."
-        },
-        "children": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Text of the component.\n@deprecated : Please use `text` instead."
-        },
-        "showOverflowInPopover": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines if the full text should be displayed inside a `ResponsivePopover` or in-place.\n@deprecated : Please use `overflowMode` instead."
-        },
-        "renderWhitespace": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines how white-space inside <code>Text</code> is handled. If set to true, sequences of white space are preserved."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ExpandableTextDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "FileUploader": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `FileUploader` opens a file explorer dialog and enables users to upload files.\nThe component consists of input field, but you can provide an HTML element by your choice\nto trigger the file upload, by using the default slot.\nFurthermore, you can set the property \"hideInput\" to \"true\" to hide the input field.\n\nTo get all selected files, you can simply use the read-only \"files\" property.\nTo restrict the types of files the user can select, you can use the \"accept\" property.\n\nAnd, similar to all input based components, the FileUploader supports \"valueState\", \"placeholder\", \"name\", and \"disabled\" properties.\n\nFor the `FileUploader`\n\n\n__Note:__ This is a UI5 Web Component! [FileUploader UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/FileUploader) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "This slot allows you to add custom content to the component, such as a button or any other interactive element to trigger the file selection dialog.\n\n**Note:** For best accessibility experience, set a `tabindex` of \"-1\" on your interactive element, or it will be set automatically.\nThis slot is intended for use cases where you want a button-only file uploader.\nIt is recommended to set `hideInput` property to \"true\" when using this slot.\nNot setting `hideInput` may negatively impact the screen reader users.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<FileUploaderDomRef, FileUploaderChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Event is fired when the value of the file path has been changed.\n\n**Note:** Keep in mind that because of the HTML input element of type file, the event is also fired in Chrome browser when the Cancel button of the uploads window is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "files",
-                "type": "FileList | null",
-                "description": "The current files."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onFileSizeExceed": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<FileUploaderDomRef, FileUploaderFileSizeExceedEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Event is fired when the size of a file is above the `maxFileSize` property value.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "filesData",
-                "type": "Array<FileData>",
-                "description": "An array of `FileData` objects containing the`fileName` and `fileSize` in MB of each file that exceeds the upload limit."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accept": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Comma-separated list of file types that the component should accept.\n\n**Note:** Please make sure you are adding the `.` in front on the file type, e.g. `.png` in case you want to accept png's only."
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the input.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideInput": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "If set to \"true\", the input field of component will not be rendered. Only the default slot that is passed will be rendered.\n\n**Note:** Use this property in combination with the default slot to achieve a button-only file uploader design.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "maxFileSize": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the maximum file size in megabytes which prevents the upload if at least one file exceeds it.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**."
-        },
-        "multiple": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Allows multiple files to be chosen.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint intended to aid the user with data entry when the component has no value."
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the name/names of the file/files to upload."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<FileUploaderDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "FilterItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `FilterItem` component defines the filtering criteria for data in `ViewSettingsDialog`.\nIt represents a single filter category that contains multiple filter options that users can select.\n\n### Usage\n\nThe `FilterItem` is used within the `ViewSettingsDialog` to provide filtering options.\n\n\n\n__Note:__ This is a UI5 Web Component! [FilterItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/FilterItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "values": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the filter options available for this filter category.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"values\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<FilterItemOption>`"
-        },
-        "additionalText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the additional text of the filter item.\nThis text is typically used to show the number of selected filter options within this category."
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the filter item."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<FilterItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "FilterItemOption": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `FilterItemOption` component defines individual filter values within a `FilterItem`.\nIt represents a single selectable option that users can choose to filter data.\n\n### Usage\n\nThe `FilterItemOption` is used as a child component within `FilterItem` in the context\nof `ViewSettingsDialog`. Each option represents a specific value that can be used for filtering\n\n\n\n__Note:__ This is a UI5 Web Component! [FilterItemOption UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/FilterItemOption) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the filter option is selected.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the filter option."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<FilterItemOptionDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "FlexibleColumnLayout": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `FlexibleColumnLayout` implements the list-detail-detail paradigm by displaying up to three pages in separate columns.\nThere are several possible layouts that can be changed either with the component API, or by dragging the column separators.\n\n### Usage\n\nUse this component for applications that need to display several logical levels of related information side by side (e.g. list of items, item, sub-item, etc.).\nThe Component is flexible in a sense that the application can focus the user's attention on one particular column.\n\n### Responsive Behavior\n\nThe `FlexibleColumnLayout` automatically displays the maximum possible number of columns based on `layout` property and the window size.\nThe component would display 1 column for window size smaller than 599px, up to two columns between 599px and 1023px,\nand 3 columns for sizes bigger than 1023px.\n\n**Note:** When the component displays more than one column, the minimal width of each column is 248px. Consequently, when the user drags a column separator to resize the columns, the minimal allowed width of any resized column is 248px.\n\n### Keyboard Handling\n\n#### Basic Navigation\n\nWhen a column separator is focused,  the following keyboard\nshortcuts allow the user to resize the columns and change the layout:\n\n- [Shift] + [Left] or [Shift] + [Right] - Moves the separator to the left or right, which resizes the columns accordingly.\n- [Left] or [Right] - Moves the separator to the left or right with a bigger step, which resizes the columns accordingly.\n- [Home] - Moves the separator to the start position.\n- [End] - Moves the separator to the end position.\n- This component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [FlexibleColumnLayout UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/FlexibleColumnLayout) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "endColumn": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content in the end column.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"endColumn\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "midColumn": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content in the middle column.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"midColumn\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "startColumn": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content in the start column.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"startColumn\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onLayoutChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<FlexibleColumnLayoutDomRef, FlexibleColumnLayoutLayoutChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the layout changes via user interaction by dragging the separators\nor by changing the component size due to resizing.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "columnLayout",
-                "type": "array",
-                "description": "The effective column layout, f.e [67%, 33%, 0]"
-              },
-              {
-                "name": "endColumnVisible",
-                "type": "boolean",
-                "description": "Indicates if the end column is currently visible"
-              },
-              {
-                "name": "layout",
-                "type": "FCLLayout",
-                "description": "The current layout"
-              },
-              {
-                "name": "midColumnVisible",
-                "type": "boolean",
-                "description": "Indicates if the middle column is currently visible"
-              },
-              {
-                "name": "resized",
-                "type": "boolean",
-                "description": "Indicates if the layout was changed by resizing the entire component"
-              },
-              {
-                "name": "separatorsUsed",
-                "type": "boolean",
-                "description": "Indicates if the layout was changed by dragging the column separators"
-              },
-              {
-                "name": "startColumnVisible",
-                "type": "boolean",
-                "description": "Indicates if the start column is currently visible"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onLayoutConfigurationChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<FlexibleColumnLayoutDomRef, FlexibleColumnLayoutLayoutConfigurationChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `layoutsConfiguration` changes via user interaction by dragging the separators.\n\n**Note:** The `layout-configuration-change` event is in an experimental state and is a subject to change.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "columnLayout",
-                "type": "array",
-                "description": "The effective column layout, f.e [\"67%\", \"33%\", \"0px\"]"
-              },
-              {
-                "name": "layout",
-                "type": "FCLLayout",
-                "description": "The current layout"
-              },
-              {
-                "name": "media",
-                "type": "MEDIA",
-                "description": "The current media type"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "FCLAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines additional accessibility attributes on different areas of the component.\n\nThe accessibilityAttributes object has the following fields,\nwhere each field is an object supporting one or more accessibility attributes:\n\n - **startColumn**: `startColumn.role` and `startColumn.name`.\n - **midColumn**: `midColumn.role` and `midColumn.name`.\n - **endColumn**: `endColumn.role` and `endColumn.name`.\n - **startSeparator**: `startSeparator.role` and `startSeparator.name`.\n - **endSeparator**: `endSeparator.role` and `endSeparator.name`.\n\nThe accessibility attributes support the following values:\n\n- **role**: Defines the accessible ARIA landmark role of the area.\nAccepts the following values: `none`, `complementary`, `contentinfo`, `main` or `region`.\n\n- **name**: Defines the accessible ARIA name of the area.\nAccepts any string.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "disableResizing": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Specifies if the user is allowed to change the columns layout by dragging the separator between the columns.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "layout": {
-          "type": {
-            "name": "enum",
-            "raw": "FCLLayout | \"OneColumn\" | \"TwoColumnsStartExpanded\" | \"TwoColumnsMidExpanded\" | \"ThreeColumnsMidExpanded\" | \"ThreeColumnsEndExpanded\" | \"ThreeColumnsStartExpandedEndHidden\" | ... 4 more ... | \"EndColumnFullScreen\"",
-            "value": [
-              {
-                "value": "\"OneColumn\"",
-                "description": "The layout will display 1 column."
-              },
-              {
-                "value": "\"TwoColumnsStartExpanded\"",
-                "description": "\nDesktop: Defaults to 67 - 33 - -- percent widths of columns. Start (expanded) and Mid columns are displayed.\nTablet:  Defaults to 67 - 33 - -- percent widths of columns. Start (expanded) and Mid columns are displayed.\nPhone:   Fixed -- 100 -- percent widths of columns, only the Mid column is displayed\n\nUse to display both a list and a detail page when the user should focus on the list page."
-              },
-              {
-                "value": "\"TwoColumnsMidExpanded\"",
-                "description": "Desktop: Defaults to 33 - 67 - -- percent widths of columns. Start and Mid (expanded) columns are displayed\nTablet:  Defaults to 33 - 67 - -- percent widths of columns. Start and Mid (expanded) columns are displayed\nPhone:   Fixed -- 100 -- percent widths of columns, only the Mid column is displayed\n\nUse to display both a list and a detail page when the user should focus on the detail page."
-              },
-              {
-                "value": "\"ThreeColumnsMidExpanded\"",
-                "description": "Desktop: Defaults to 25 - 50 - 25 percent widths of columns. Start, Mid (expanded) and End columns are displayed\nTablet:  Defaults to 0 - 67 - 33 percent widths of columns. Mid (expanded) and End columns are displayed, Start is accessible by dragging the columns-separator\nPhone:   Fixed -- -- 100 percent widths of columns, only the End column is displayed\n\nUse to display all three pages (list, detail, detail-detail) when the user should focus on the detail."
-              },
-              {
-                "value": "\"ThreeColumnsEndExpanded\"",
-                "description": "Desktop: Defaults to 25 - 25 - 50 percent widths of columns. Start, Mid and End (expanded) columns are displayed\nTablet:  Defaults to 0 - 33 - 67 percent widths of columns. Mid and End (expanded) columns are displayed, Start is accessible by dragging the columns-separator\nPhone:   Fixed -- -- 100 percent widths of columns (only the End column is displayed)\n\nUse to display all three pages (list, detail, detail-detail) when the user should focus on the detail-detail."
-              },
-              {
-                "value": "\"ThreeColumnsStartExpandedEndHidden\"",
-                "description": "Desktop: Defaults to 67 - 33 - 0 percent widths of columns. Start (expanded) and Mid columns are displayed, End is accessible by dragging the columns-separator\nTablet:  Defaults to 67 - 33 - 0 percent widths of columns. Start (expanded) and Mid columns are displayed, End is accessible by dragging the columns-separator\nPhone:   Fixed -- -- 100 percent widths of columns, only the End column is displayed\n\nUse to display the list and detail pages when the user should focus on the list.\nThe detail-detail is still loaded and easily accessible by dragging the columns-separator"
-              },
-              {
-                "value": "\"ThreeColumnsMidExpandedEndHidden\"",
-                "description": "Desktop: Defaults to 33 - 67 - 0 percent widths of columns. Start and Mid (expanded) columns are displayed, End is accessible by dragging the columns-separator\nTablet:  Defaults to 33 - 67 - 0 percent widths of columns. Start and Mid (expanded) columns are displayed, End is accessible by dragging the columns-separator\nPhone:   Fixed -- -- 100 percent widths of columns, only the End column is displayed\n\nUse to display the list and detail pages when the user should focus on the detail.\nThe detail-detail is still loaded and easily accessible by dragging the columns-separator"
-              },
-              {
-                "value": "\"ThreeColumnsStartHiddenMidExpanded\"",
-                "description": "Desktop: Defaults to 0 - 67 - 33 percent widths of columns. Start is hidden, Mid (expanded) and End columns are displayed.\nTablet:  Defaults to 0 - 67 - 33 percent widths of columns. Start is hidden, Mid (expanded) and End columns are displayed.\nPhone:   Fixed -- 100 percent width of the Mid column, only the Mid column is displayed.\n\nUse to display the Mid and End columns while the Start column is hidden."
-              },
-              {
-                "value": "\"ThreeColumnsStartHiddenEndExpanded\"",
-                "description": "Desktop: Defaults to 0 - 33 - 67 percent widths of columns. Start is hidden, Mid and End (expanded) columns are displayed.\nTablet:  Defaults to 0 - 33 - 67 percent widths of columns. Start is hidden, Mid and End (expanded) columns are displayed.\nPhone:   Fixed -- 100 percent width of the End column, only the End column is displayed.\n\nUse to display the Mid column and expanded End column while the grip of the separator is not visible."
-              },
-              {
-                "value": "\"MidColumnFullScreen\"",
-                "description": "Desktop: Fixed -- 100 -- percent widths of columns, only the Mid column is displayed\nTablet:  Fixed -- 100 -- percent widths of columns, only the Mid column is displayed\nPhone:   Fixed -- 100 -- percent widths of columns, only the Mid column is displayed\n\nUse to display a detail page only, when the user should focus entirely on it."
-              },
-              {
-                "value": "\"EndColumnFullScreen\"",
-                "description": "Desktop: Fixed -- -- 100 percent widths of columns, only the End column is displayed\nTablet:  Fixed -- -- 100 percent widths of columns, only the End column is displayed\nPhone:   Fixed -- -- 100 percent widths of columns, only the End column is displayed\n\nUse to display a detail-detail page only, when the user should focus entirely on it."
-              },
-              {
-                "value": "\"OneColumn\""
-              },
-              {
-                "value": "\"TwoColumnsStartExpanded\""
-              },
-              {
-                "value": "\"TwoColumnsMidExpanded\""
-              },
-              {
-                "value": "\"ThreeColumnsMidExpanded\""
-              },
-              {
-                "value": "\"ThreeColumnsEndExpanded\""
-              },
-              {
-                "value": "\"ThreeColumnsStartExpandedEndHidden\""
-              },
-              {
-                "value": "\"ThreeColumnsMidExpandedEndHidden\""
-              },
-              {
-                "value": "\"ThreeColumnsStartHiddenMidExpanded\""
-              },
-              {
-                "value": "\"ThreeColumnsStartHiddenEndExpanded\""
-              },
-              {
-                "value": "\"MidColumnFullScreen\""
-              },
-              {
-                "value": "\"EndColumnFullScreen\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the columns layout and their proportion.\n\n**Note:** The layout also depends on the screen size - one column for screens smaller than 599px,\ntwo columns between 599px and 1023px and three columns for sizes bigger than 1023px.\n\n**For example:** layout=`TwoColumnsStartExpanded` means the layout will display up to two columns\nin 67%/33% proportion.",
-          "defaultValue": {
-            "value": "\"OneColumn\""
-          }
-        },
-        "layoutsConfiguration": {
-          "type": {
-            "name": "LayoutConfiguration"
-          },
-          "required": false,
-          "description": "Allows to customize the column proportions per screen size and layout.\nIf no custom proportion provided for a specific layout, the default will be used.\n\n**Notes:**\n\n- The proportions should be given in percentages. For example [\"30%\", \"40%\", \"30%\"], [\"70%\", \"30%\", 0], etc.\n- The proportions should add up to 100%.\n- Hidden columns are marked as \"0px\", e.g. [\"0px\", \"70%\", \"30%\"]. Specifying 0 or \"0%\" for hidden columns is also valid.\n- If the proportions do not match the layout (e.g. if provided proportions [\"70%\", \"30%\", \"0px\"] for \"OneColumn\" layout), then the default proportions will be used instead.\n- Whenever the user drags the columns separator to resize the columns, the `layoutsConfiguration` object will be updated with the user-specified proportions for the given layout (and the `layout-configuration-change` event will be fired).\n- No custom configuration available for the phone screen size, as the default of 100% column width is always used there.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<FlexibleColumnLayoutDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Form": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The Form is a layout component that arranges labels and form fields (like input fields) pairs\ninto a specific number of columns.\n\n**Note:** The Form web component is a layout component, it isn't a replacement for the native `form` HTML element.\nThe Form web component does not provide any APIs for form submission.\n\n### Structure\n\n- **Form** (`Form`) is the top-level container component, responsible for the content layout and responsiveness.\n- **FormGroup** (`FormGroup`) enables the grouping of the Form content.\n- **FormItem** (`FormItem`) is a pair of label and form fields and can be used directly in a Form, or as part of a FormGroup.\n\nThe simplest Form (`Form`) consists of a header area on top,\ndisplaying a header text (see the `headingText` property) and content below - an arbitrary number of FormItems (ui5-form-item),\nrepresenting the pairs of label and form fields.\n\nAnd, there is also \"grouping\" available to assist the implementation of richer UIs.\nThis is enabled by the FormGroup (`FormGroup`) component.\nIn this case, the Form is structured into FormGroups and each FormGroup consists of FormItems.\n\n### Responsiveness\n\nThe Form component reacts and changes its layout on predefined breakpoints.\nDepending on its size, the Form content (FormGroups and FormItems) gets divided into one or more columns as follows:\n- **S** (< 600px) – 1 column is recommended (default: 1)\n- **M** (600px - 1022px) – up to 2 columns are recommended (default: 1)\n- **L** (1023px - 1439px) - up to 3 columns are recommended (default: 2)\n- **XL** (> 1439px) – up to 6 columns are recommended (default: 3)\n\nTo change the layout, use the `layout` property - f.e. layout=\"S1 M2 L3 XL6\".\n\n### Groups\n\nTo make better use of screen space, there is built-in logic to determine how many columns should a FormGroup occupy.\n\n- **Example #1** (perfect match):\n4 columns and 4 groups: each group will use 1 column.\n\n- **Example #2** (balanced distribution):\n4 columns and 2 groups: each group will use 2 columns.\n6 columns and 2 groups: each group will use 3 columns.\n\n- **Example #3** (unbalanced distribution):\n3 columns and 2 groups: the larger one will use 2 columns, the smaller 1 column.\n5 columns and 3 groups: two of the groups will use 2 columns each, the smallest 1 column.\n\n**Note:** The size of a group element is determined by the number of FormItems assigned to it.\nIn the case of equality, the first in the DOM will use more columns, and the last - fewer columns.\n\n- **Example #4** (more groups than columns):\n3 columns and 4 groups: each FormGroup uses only 1 column, the last FormGroup will wrap on the second row.\n\n### Groups Column Span\n\nTo influence the built-in group distribution, described in the previous section,\nyou can use the FormGroup's `columnSpan` property, that defines how many columns the group should expand to.\n\n### Items Column Span\n\nFormItem's columnSpan property defines how many columns the form item should expand to inside a form group or the form.\n\n### Items Label Span\n\nThe placement of the labels depends on the size of the used column.\nIf there is enough space, the labels are next to their associated fields, otherwise  - above the fields.\nBy default, the labels take 4/12 of the FormItem, leaving 8/12 parts to associated fields.\nYou can control what space the labels should take via the `labelSpan` property.\n\n**For example:** To always place the labels on top set: `labelSpan=\"S12 M12 L12 XL12\"` property.\n\n### Items Empty Span\n\nBy default, a form item spans 12 cells, fully divided between its label and field, with no empty space at the end:\n- **Label:** occupies 4 cells.\n- **Field:** occupies 8 cells.\n\nThe `emptySpan` property provides additional layout flexibility by defining empty space at the form item’s end.\n\n**For example:** Setting \"S0 M0 L3 XL3\" (or just \"L3 XL3\") adjusts the layout as follows:\n- **Label:** remains 4 cells.\n- **Field:** is reduced to 5 cells.\n- **Empty space:** 3 cells are added at the end.\n\nGreater values increase the empty space at the end of the form item, reducing the space available for the label and its field.\nHowever, setting `emptySpan` to 1 cell is recommended and typically sufficient to achieve a balanced layout.\n\n### Navigation flow\n\nThe Form component supports two layout options for keyboard navigation:\n\n#### Simple form\n\nIn this \"simple form\" layout, each `FormItem` acts as a standalone group\nwith one item, so focus moves horizontally across the grid from one `FormItem` to the next.\nThis layout is ideal for simpler forms and supports custom arrangements, e.g.,\n\n```\n| 1 | 2 |\n|   3   |\n| 4 | 5 |\n```\n\n#### Complex form\n\nIn this layout, items are grouped into `FormGroup` elements, allowing more complex configurations:\n\n- **Single-Column Group**: Focus moves vertically down from one item to the next.\n  ```\n  | 1 |\n  | 2 |\n  | 3 |\n  ```\n\n- **Multi-Column Group**: Focus moves horizontally within each row, advancing to the next row after completing the current one.\n  ```\n  | 1 | 4 |\n  | 2 | 5 |\n  | 3 | 6 |\n  ```\n\n### Keyboard Handling\n\n- [Tab] - Moves the focus to the next interactive element within the Form/FormGroup (if available) or to the next element in the tab chain outside the Form\n- [Shift] + [Tab] - Moves the focus to the previous interactive element within the Form/FormGroup (if available) or to the previous element in the tab chain outside the Form\n- [F6] - Moves the focus to the first interactive element of the next FormGroup (if available) or to the next element in the tab chain outside the Form\n- [Shift] + [F6] - Moves the focus to the first interactive element of the previous FormGroup (if available) or to the previous element in the tab chain outside the Form\n\n### ES6 Module Import\n\n- import\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the component content - FormGroups or FormItems.\n\n**Note:** Mixing FormGroups and standalone FormItems (not belonging to a group) is not supported.\nEither use FormGroups and make sure all FormItems are part of a FormGroup, or use just FormItems without any FormGroups.\n\n__Supported Node Type/s:__ `Array<IFormItem>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the component header area.\n\n**Note:** When a `header` is provided, the `headerText` property is ignored.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "accessibleMode": {
-          "type": {
-            "name": "enum",
-            "raw": "FormAccessibleMode | \"Display\" | \"Edit\"",
-            "value": [
-              {
-                "value": "\"Display\"",
-                "description": "Display mode."
-              },
-              {
-                "value": "\"Edit\"",
-                "description": "Edit mode."
-              },
-              {
-                "value": "\"Display\""
-              },
-              {
-                "value": "\"Edit\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the accessibility mode of the component in \"edit\" and \"display\" use-cases.\n\nBased on the mode, the component renders different HTML elements and ARIA attributes,\nwhich are appropriate for the use-case.\n\n**Usage:**\n- Set this property to \"Display\", when the form consists of non-editable (e.g. texts) form items.\n- Set this property to \"Edit\", when the form consists of editable (e.g. input fields) form items.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Display\""
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines id (or many ids) of the element (or elements) that label the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
-        },
-        "emptySpan": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the number of cells that are empty at the end of each form item, configurable by breakpoint.\n\nBy default, a form item spans 12 cells, fully divided between its label (4 cells) and field (8 cells), with no empty space at the end.\nThe `emptySpan` provides additional layout flexibility by defining empty space at the form item’s end.\n\n**Note:**\n- The maximum allowable empty space is 10 cells. At least 1 cell each must remain for the label and the field.\n- When `emptySpan` is specified (greater than 0), ensure that the combined value of `emptySpan` and `labelSpan` does not exceed 11. This guarantees a minimum of 1 cell for the field.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"S0 M0 L0 XL0\""
-          }
-        },
-        "headerLevel": {
-          "type": {
-            "name": "enum",
-            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
-            "value": [
-              {
-                "value": "\"H1\"",
-                "description": "Renders `h1` tag."
-              },
-              {
-                "value": "\"H2\"",
-                "description": "Renders `h2` tag."
-              },
-              {
-                "value": "\"H3\"",
-                "description": "Renders `h3` tag."
-              },
-              {
-                "value": "\"H4\"",
-                "description": "Renders `h4` tag."
-              },
-              {
-                "value": "\"H5\"",
-                "description": "Renders `h5` tag."
-              },
-              {
-                "value": "\"H6\"",
-                "description": "Renders `h6` tag."
-              },
-              {
-                "value": "\"H1\""
-              },
-              {
-                "value": "\"H2\""
-              },
-              {
-                "value": "\"H3\""
-              },
-              {
-                "value": "\"H4\""
-              },
-              {
-                "value": "\"H5\""
-              },
-              {
-                "value": "\"H6\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the compoennt heading level,\nset by the `headerText`.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"H2\""
-          }
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text of the component.\n\n**Note:** The property gets overridden by the `header` slot."
-        },
-        "itemSpacing": {
-          "type": {
-            "name": "enum",
-            "raw": "FormItemSpacing | \"Normal\" | \"Large\"",
-            "value": [
-              {
-                "value": "\"Normal\"",
-                "description": "Normal spacing (smaller vertical space between form items)."
-              },
-              {
-                "value": "\"Large\"",
-                "description": "Large spacing (larger vertical space between form items)."
-              },
-              {
-                "value": "\"Normal\""
-              },
-              {
-                "value": "\"Large\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the vertical spacing between form items.\n\n**Note:** If the Form is meant to be switched between \"display\"(\"non-edit\") and \"edit\" modes,\nwe recommend using \"Large\" item spacing in \"display\"(\"non-edit\") mode, and \"Normal\" - for \"edit\" mode,\nto avoid \"jumping\" effect, caused by the hight difference between texts in \"display\"(\"non-edit\") mode and the input fields in \"edit\" mode.",
-          "defaultValue": {
-            "value": "\"Normal\""
-          }
-        },
-        "labelSpan": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the width proportion of the labels and fields of a form item by breakpoint.\n\nBy default, the labels take 4/12 (or 1/3) of the form item in M,L and XL sizes,\nand 12/12 in S size, e.g in S the label is on top of its associated field.\n\nThe supported values are between 1 and 12. Greater the number, more space the label will use.\n\n**Note:** If \"12\" is set, the label will be displayed on top of its assosiated field.",
-          "defaultValue": {
-            "value": "\"S12 M4 L4 XL4\""
-          }
-        },
-        "layout": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the number of columns to distribute the form content by breakpoint.\n\nSupported values:\n- `S` - 1 column by default (1 column is recommended)\n- `M` - 1 column by default (up to 2 columns are recommended)\n- `L` - 2 columns by default (up to 3 columns are recommended)\n- `XL` - 3 columns by default (up to 6 columns  are recommended)",
-          "defaultValue": {
-            "value": "\"S1 M1 L2 XL3\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<FormDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "column",
-          "description": "Used to style a single column of the form column layout."
-        },
-        {
-          "name": "header",
-          "description": "Used to style the wrapper of the header."
-        },
-        {
-          "name": "layout",
-          "description": "Used to style the element defining the form column layout."
-        }
-      ]
-    },
-    "FormGroup": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The FormGroup (ui5-form-group) represents a group inside the Form (ui5-form) component\nand it consists of FormItem (ui5-form-item) components.\n\nThe layout of the FormGroup is mostly defined and controlled by the overarching Form (ui5-form) component.\nStill, one can influence the layout via the FormGroup's `columnSpan` property,\nthat defines how many columns the group should expand to.\n\n### Usage\n\nТhe FormGroup (ui5-form-group) allows to split a Form into groups,\ne.g to group FormItems that logically belong together.\n\n### ES6 Module Import\n\n- import\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the component.\n\n__Supported Node Type/s:__ `Array<FormItem>`"
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines id (or many ids) of the element (or elements) that label the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
-        },
-        "columnSpan": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines column span of the component,\ne.g how many columns the group should span to."
-        },
-        "headerLevel": {
-          "type": {
-            "name": "enum",
-            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
-            "value": [
-              {
-                "value": "\"H1\"",
-                "description": "Renders `h1` tag."
-              },
-              {
-                "value": "\"H2\"",
-                "description": "Renders `h2` tag."
-              },
-              {
-                "value": "\"H3\"",
-                "description": "Renders `h3` tag."
-              },
-              {
-                "value": "\"H4\"",
-                "description": "Renders `h4` tag."
-              },
-              {
-                "value": "\"H5\"",
-                "description": "Renders `h5` tag."
-              },
-              {
-                "value": "\"H6\"",
-                "description": "Renders `h6` tag."
-              },
-              {
-                "value": "\"H1\""
-              },
-              {
-                "value": "\"H2\""
-              },
-              {
-                "value": "\"H3\""
-              },
-              {
-                "value": "\"H4\""
-              },
-              {
-                "value": "\"H5\""
-              },
-              {
-                "value": "\"H6\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the compoennt heading level,\nset by the `headerText`.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"H3\""
-          }
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines header text of the component."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<FormGroupDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "FormItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The FormItem (ui5-form-item) represents pair of a label and\none or more components (text or text fields), associated to it.\n\n### Usage\n\nThe FormItem is being used in FormGroup (ui5-form-group) or directly in Form (ui5-form).\n\n### ES6 Module Import\n\n- import\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component,\nassociated to `labelContent`.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "labelContent": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the label of the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"labelContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "columnSpan": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the column span of the component,\ne.g how many columns the component should span to.\n\n**Note:** The column span should be a number between 1 and the available columns of the FormGroup (when items are placed in a group)\nor the Form. The available columns can be affected by the FormGroup#columnSpan and/or the Form#layout.\nA number bigger than the available columns won't take effect."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<FormItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "content",
-          "description": "Used to style the content part of the form item."
-        },
-        {
-          "name": "label",
-          "description": "Used to style the label part of the form item."
-        },
-        {
-          "name": "layout",
-          "description": "Used to style the parent element of the label and content parts."
-        }
-      ]
-    },
-    "GroupItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `GroupItem` component defines the grouping criteria for data in `ViewSettingsDialog`.\nIt represents a single group option that users can select to organize data into logical groups.\n\n### Usage\n\nThe `GroupItem` is used within the `ViewSettingsDialog` to provide grouping options.\nEach group item represents a column or field by which data can be grouped.\n\n\n\n__Note:__ This is a UI5 Web Component! [GroupItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/GroupItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the group item is selected.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the group item."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<GroupItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Icon": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Icon` component represents an SVG icon.\nThere are two main scenarios how the `Icon` component is used:\nas a purely decorative element,\nor as an interactive element that can be focused and clicked.\n\n### Usage\n\n1. **Get familiar with the icons collections.**\n\nBefore displaying an icon, you need to explore the icons collections to find and import the desired icon.\n\nCurrently there are 3 icons collection, available as 3 npm packages:\n\n- [@ui5/webcomponents-icons](https://www.npmjs.com/package/@ui5/webcomponents-icons) represents the \"SAP-icons\" collection and includes the following\n[icons](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html#/overview/SAP-icons).\n- [@ui5/webcomponents-icons-tnt](https://www.npmjs.com/package/@ui5/webcomponents-icons-tnt) represents the \"tnt\" collection and includes the following\n[icons](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html#/overview/SAP-icons-TNT).\n- [@ui5/webcomponents-icons-business-suite](https://www.npmjs.com/package/@ui5/webcomponents-icons-business-suite) represents the \"business-suite\" collection and includes the following\n[icons](https://ui5.sap.com/test-resources/sap/m/demokit/iconExplorer/webapp/index.html#/overview/BusinessSuiteInAppSymbols).\n\n2. **After exploring the icons collections, add one or more of the packages as dependencies to your project.**\n\n`npm i\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<IconDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired on mouseup, `SPACE` and `ENTER`.\n- on mouse click, the icon fires native `click` event\n- on `SPACE` and `ENTER`, the icon fires custom `click` event\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text alternative of the component.\nIf not provided a default text alternative will be set, if present.\n\n**Note:** Every icon should have a text alternative in order to\ncalculate its accessible name."
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "IconDesign | \"Contrast\" | \"Critical\" | \"Default\" | \"Information\" | \"Negative\" | \"Neutral\" | \"NonInteractive\" | \"Positive\"",
-            "value": [
-              {
-                "value": "\"Contrast\"",
-                "description": "Contrast design"
-              },
-              {
-                "value": "\"Critical\"",
-                "description": "Critical design"
-              },
-              {
-                "value": "\"Default\"",
-                "description": "Default design (brand design)"
-              },
-              {
-                "value": "\"Information\"",
-                "description": "info type"
-              },
-              {
-                "value": "\"Negative\"",
-                "description": "Negative design"
-              },
-              {
-                "value": "\"Neutral\"",
-                "description": "Neutral design"
-              },
-              {
-                "value": "\"NonInteractive\"",
-                "description": "Design that indicates an icon which isn't interactive"
-              },
-              {
-                "value": "\"Positive\"",
-                "description": "Positive design"
-              },
-              {
-                "value": "\"Contrast\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Neutral\""
-              },
-              {
-                "value": "\"NonInteractive\""
-              },
-              {
-                "value": "\"Positive\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component semantic design.\n\n**Note:** Available since [v1.9.2](https://github.com/UI5/webcomponents/releases/tag/v1.9.2) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "mode": {
-          "type": {
-            "name": "enum",
-            "raw": "IconMode | \"Image\" | \"Decorative\" | \"Interactive\"",
-            "value": [
-              {
-                "value": "\"Image\"",
-                "description": "Image mode (by default).\nConfigures the component to internally render role=\"img\"."
-              },
-              {
-                "value": "\"Decorative\"",
-                "description": "Decorative mode.\nConfigures the component to internally render role=\"presentation\" and aria-hidden=\"true\",\nmaking it purely decorative without semantic content or interactivity."
-              },
-              {
-                "value": "\"Interactive\"",
-                "description": "Interactive mode.\nConfigures the component to internally render role=\"button\".\nThis mode also supports focus and press handling to enhance interactivity."
-              },
-              {
-                "value": "\"Image\""
-              },
-              {
-                "value": "\"Decorative\""
-              },
-              {
-                "value": "\"Interactive\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the mode of the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Decorative\""
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the unique identifier (icon name) of the component.\n\nTo browse all available icons, see the\n[SAP Icons](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html),\n[SAP Fiori Tools](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html#/overview/SAP-icons-TNT) and\n[SAP Business Suite](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)\n\nExample:\n`name='add'`, `name='delete'`, `name='employee'`.\n\n**Note:** To use the SAP Fiori Tools icons,\nyou need to set the `tnt` prefix in front of the icon's name.\n\nExample:\n`name='tnt/antenna'`, `name='tnt/actor'`, `name='tnt/api'`.\n\n**Note:** To use the SAP Business Suite icons,\nyou need to set the `business-suite` prefix in front of the icon's name.\n\nExample:\n`name='business-suite/3d'`, `name='business-suite/1x2-grid-layout'`, `name='business-suite/4x4-grid-layout'`."
-        },
-        "showTooltip": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should have a tooltip.\n\n**Note:** The tooltip text should be provided via the `accessible-name` property.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<IconDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "root",
-          "description": "Used to style the outermost wrapper of the `ui5-icon`."
-        }
-      ]
-    },
-    "IllustratedMessage": {
-      "package": "@ui5/webcomponents-react",
-      "description": "An IllustratedMessage is a recommended combination of a solution-oriented message, an engaging\nillustration, and conversational tone to better communicate an empty or a success state than just show\na message alone.\n\nEach illustration has default internationalised title and subtitle texts. Also they can be managed with\n`titleText` and `subtitleText` properties.\n\nTo display the desired illustration, use the `name` property, where you can find the list of all available illustrations.\n\n**Note:** By default the “BeforeSearch” illustration is loaded. To use other illustrations, make sure you import them in addition, for example:\n\n`import \"@ui5/webcomponents-fiori/dist/illustrations/NoData.js\"`\n\n**Note:** Illustrations starting with the “Tnt” prefix are part of another illustration set. For example to use the “TntSuccess” illustration, add the following import::\n\n`import \"@ui5/webcomponents-fiori/dist/illustrations/tnt/Success.js\"`\n\n### Structure\nThe IllustratedMessage consists of the following elements, which are displayed below each other in the following order:\n\n- Illustration\n- Title\n- Subtitle\n- Actions\n\n### Usage\n`IllustratedMessage` is meant to be used inside container component, for example a `ui5-card`,\na `ui5-dialog` or a `Page`\n\n\n\n__Note:__ This is a UI5 Web Component! [IllustratedMessage UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/IllustratedMessage) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the component actions.\n\n**Note:** Not displayed when the `design` property is set to `Base`.\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "subtitle": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the subtitle of the component.\n\n**Note:** Using this slot, the default subtitle text of illustration and the value of `subtitleText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"subtitle\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "title": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the title of the component.\n\n**Note:** Using this slot, the default title text of illustration and the value of `title` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"title\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.7.0](https://github.com/UI5/webcomponents/releases/tag/v1.7.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement> & string`"
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.7.0](https://github.com/UI5/webcomponents/releases/tag/v1.7.0) of **@ui5/webcomponents-fiori**."
-        },
-        "decorative": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the illustration is decorative.\n\nWhen set to `true`, the attributes `role=\"presentation\"` and `aria-hidden=\"true\"` are applied to the SVG element.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "IllustrationMessageDesign | \"Auto\" | \"Base\" | \"Dot\" | \"Spot\" | \"Dialog\" | \"Scene\" | \"ExtraSmall\" | \"Small\" | \"Medium\" | \"Large\"",
-            "value": [
-              {
-                "value": "\"Auto\"",
-                "description": "Automatically decides the <code>Illustration</code> size (<code>Base</code>, <code>Dot</code>, <code>Spot</code>,\n<code>Dialog</code>, or <code>Scene</code>) depending on the <code>IllustratedMessage</code> container width.\n\n**Note:** `Auto` is the only option where the illustration size is changed according to\nthe available container width. If any other `IllustratedMessageSize` is chosen, it remains\nuntil changed by the app developer."
-              },
-              {
-                "value": "\"Base\"",
-                "description": "Base `Illustration` size (XS breakpoint). Suitable for cards (two columns).\n\n**Note:** When `Base` is in use, no illustration is displayed."
-              },
-              {
-                "value": "\"Dot\"",
-                "description": "Dot <code>Illustration</code> size (XS breakpoint). Suitable for table rows."
-              },
-              {
-                "value": "\"Spot\"",
-                "description": "Spot <code>Illustration</code> size (S breakpoint). Suitable for cards (four columns)."
-              },
-              {
-                "value": "\"Dialog\"",
-                "description": "Dialog `Illustration` size (M breakpoint). Suitable for dialogs."
-              },
-              {
-                "value": "\"Scene\"",
-                "description": "Scene `Illustration` size (L breakpoint). Suitable for a `Page` or a table."
-              },
-              {
-                "value": "\"ExtraSmall\"",
-                "description": "ExtraSmall <code>Illustration</code> size (XS breakpoint). Suitable for table rows."
-              },
-              {
-                "value": "\"Small\"",
-                "description": "Small <code>Illustration</code> size (S breakpoint). Suitable for cards (four columns)."
-              },
-              {
-                "value": "\"Medium\"",
-                "description": "Medium `Illustration` size (M breakpoint). Suitable for dialogs."
-              },
-              {
-                "value": "\"Large\"",
-                "description": "Large `Illustration` size (L breakpoint). Suitable for a `Page` or a table."
-              },
-              {
-                "value": "\"Auto\""
-              },
-              {
-                "value": "\"Base\""
-              },
-              {
-                "value": "\"Dot\""
-              },
-              {
-                "value": "\"Spot\""
-              },
-              {
-                "value": "\"Dialog\""
-              },
-              {
-                "value": "\"Scene\""
-              },
-              {
-                "value": "\"ExtraSmall\""
-              },
-              {
-                "value": "\"Small\""
-              },
-              {
-                "value": "\"Medium\""
-              },
-              {
-                "value": "\"Large\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines which illustration breakpoint variant is used.\n\nAs `IllustratedMessage` adapts itself around the `Illustration`, the other\nelements of the component are displayed differently on the different breakpoints/illustration designs.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"Auto\""
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the illustration name that will be displayed in the component.\n\nExample:\n\n`name='BeforeSearch'`, `name='UnableToUpload'`, etc..\n\n**Note:** To use the TNT illustrations,\nyou need to set the `tnt` or `Tnt` prefix in front of the icon's name.\n\nExample:\n\n`name='tnt/Avatar'` or `name='TntAvatar'`.\n\n**Note:** By default the `BeforeSearch` illustration is loaded.\nWhen using an illustration type, other than the default, it should be loaded in addition:\n\n`import \"@ui5/webcomponents-fiori/dist/illustrations/NoData.js\";`\n\nFor TNT illustrations:\n\n`import \"@ui5/webcomponents-fiori/dist/illustrations/tnt/SessionExpired.js\";`",
-          "defaultValue": {
-            "value": "\"BeforeSearch\""
-          }
-        },
-        "subtitleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the subtitle of the component.\n\n**Note:** Using this property, the default subtitle text of illustration will be overwritten.\n\n**Note:** Using `subtitle` slot, the default of this property will be overwritten."
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the title of the component.\n\n**Note:** Using this property, the default title text of illustration will be overwritten."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<IllustratedMessageDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "subtitle",
-          "description": "Used to style the subtitle wrapper of the `ui5-illustrated-message`"
-        }
-      ]
-    },
-    "Input": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Input` component allows the user to enter and edit text or numeric values in one line.\n\nAdditionally, you can provide `suggestionItems`,\nthat are displayed in a popover right under the input.\n\nThe text field can be editable or read-only (`readonly` property),\nand it can be enabled or disabled (`disabled` property).\nTo visualize semantic states, such as \"Negative\" or \"Critical\", the `valueState` property is provided.\nWhen the user makes changes to the text, the change event is fired,\nwhich enables you to react on any text change.\n\n### Keyboard Handling\nThe `Input` provides the following keyboard shortcuts:\n\n- [Escape] - Closes the suggestion list, if open. If closed or not enabled, cancels changes and reverts to the value which the Input field had when it got the focus.\n- [Enter] or [Return] - If suggestion list is open takes over the current matching item and closes it. If value state or group header is focused, does nothing.\n- [Down] - Focuses the next matching item in the suggestion list. Selection-change event is fired.\n- [Up] - Focuses the previous matching item in the suggestion list. Selection-change event is fired.\n- [Home] - If focus is in the text input, moves caret before the first character. If focus is in the list, highlights the first item and updates the input accordingly.\n- [End] - If focus is in the text input, moves caret after the last character. If focus is in the list, highlights the last item and updates the input accordingly.\n- [Page Up] - If focus is in the list, moves highlight up by page size (10 items by default). If focus is in the input, does nothing.\n- [Page Down] - If focus is in the list, moves highlight down by page size (10 items by default). If focus is in the input, does nothing.\n- [Ctrl]+[Alt]+[F8] or [Command]+[Option]+[F8] - Focuses the first link in the value state message, if available. Pressing [Tab] moves the focus to the next link in the value state message, or closes the value state message if there are no more links.\n\n\n\n__Note:__ This is a UI5 Web Component! [Input UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Input) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the suggestion items.\n\n**Note:** The suggestions would be displayed only if the `showSuggestions`\nproperty is set to `true`.\n\n**Note:** The `<SuggestionItem>`, `<SuggestionItemGroup>` and `SuggestionItemCustom` are recommended to be used as suggestion items.\n\n__Supported Node Type/s:__ `Array<IInputSuggestionItem>`"
-        },
-        "icon": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed in the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
-        },
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n**Note:** If the component has `suggestionItems`,\nthe `valueStateMessage` would be displayed as part of the same popover, if used on desktop, or dialog - on phone.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the suggestions picker is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the component changes at each keystroke,\nand when a suggestion item has been selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the suggestions picker is open.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSelect": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when some text has been selected.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, InputSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user navigates to a suggestion item via the ARROW keys,\nas a preview, before the final selection.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The previewed suggestion item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the input."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "filter": {
-          "type": {
-            "name": "enum",
-            "raw": "InputSuggestionsFilter | \"StartsWithPerTerm\" | \"StartsWith\" | \"Contains\" | \"None\"",
-            "value": [
-              {
-                "value": "\"StartsWithPerTerm\"",
-                "description": "Defines filtering by first symbol of each word of item's text."
-              },
-              {
-                "value": "\"StartsWith\"",
-                "description": "Defines filtering by starting symbol of item's text."
-              },
-              {
-                "value": "\"Contains\"",
-                "description": "Defines contains filtering."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Removes any filtering applied while typing"
-              },
-              {
-                "value": "\"StartsWithPerTerm\""
-              },
-              {
-                "value": "\"StartsWith\""
-              },
-              {
-                "value": "\"Contains\""
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the filter type of the component.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "maxlength": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Sets the maximum number of characters available in the input field.\n\n**Note:** This property is not compatible with the ui5-input type InputType.Number. If the ui5-input type is set to Number, the maxlength value is ignored."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
-        },
-        "noTypeahead": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the value will be autcompleted to match an item\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the suggestions picker is open.\nThe picker will not open if the `showSuggestions` property is set to `false`, the input is disabled or the input is readonly.\nThe picker will close automatically and `close` event will be fired if the input is not in the viewport.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showClearIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showSuggestions": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should show suggestions, if such are present.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "InputType | \"Text\" | \"Email\" | \"Number\" | \"Password\" | \"Tel\" | \"URL\" | \"Search\"",
-            "value": [
-              {
-                "value": "\"Text\"",
-                "description": "Defines a one-line text input field:"
-              },
-              {
-                "value": "\"Email\"",
-                "description": "Used for input fields that must contain an e-mail address."
-              },
-              {
-                "value": "\"Number\"",
-                "description": "Defines a numeric input field."
-              },
-              {
-                "value": "\"Password\"",
-                "description": "Defines a password field."
-              },
-              {
-                "value": "\"Tel\"",
-                "description": "Used for input fields that should contain a telephone number."
-              },
-              {
-                "value": "\"URL\"",
-                "description": "Used for input fields that should contain a URL address."
-              },
-              {
-                "value": "\"Search\"",
-                "description": "Used for input fields that should contain a search term."
-              },
-              {
-                "value": "\"Text\""
-              },
-              {
-                "value": "\"Email\""
-              },
-              {
-                "value": "\"Number\""
-              },
-              {
-                "value": "\"Password\""
-              },
-              {
-                "value": "\"Tel\""
-              },
-              {
-                "value": "\"URL\""
-              },
-              {
-                "value": "\"Search\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the HTML type of the component.\n\n**Notes:**\n\n- The particular effect of this property differs depending on the browser\nand the current language settings, especially for type `Number`.\n- The property is mostly intended to be used with touch devices\nthat use different soft keyboard layouts depending on the given input type.",
-          "defaultValue": {
-            "value": "\"Text\""
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<InputDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "clear-icon",
-          "description": "Used to style the clear icon, which can be pressed to clear user input text"
-        },
-        {
-          "name": "input",
-          "description": "Used to style the native input element"
-        },
-        {
-          "name": "root",
-          "description": "Used to style the root DOM element of the Input component"
-        }
-      ]
-    },
-    "Label": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Label` is a component used to represent a label for elements like input, textarea, select.\nThe `for` property of the `Label` must be the same as the id attribute of the related input element.\nScreen readers read out the label, when the user focuses the labelled control.\n\nThe `Label` appearance can be influenced by properties,\nsuch as `required` and `wrappingType`.\nThe appearance of the Label can be configured in a limited way by using the design property.\nFor a broader choice of designs, you can use custom styles.\n\n\n\n__Note:__ This is a UI5 Web Component! [Label UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Label) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "for": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the labeled input by providing its ID.\n\n**Note:** Can be used with both `Input` and native input."
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether an asterisk character is added to the component text.\n\n**Note:** Usually indicates that user input (bound with the `for` property) is required.\nIn that case the `required` property of\nthe corresponding input should also be set.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showColon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether colon is added to the component text.\n\n**Note:** Usually used in forms.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "WrappingType | \"None\" | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines how the text of a component will be displayed when there is not enough space.\n\n**Note:** for option \"Normal\" the text will wrap and the words will not be broken based on hyphenation.",
-          "defaultValue": {
-            "value": "\"Normal\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<LabelDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Link": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Link` is a hyperlink component that is used to navigate to other\napps and web pages, or to trigger actions.\nIt is a clickable text element, visualized in such a way that it stands out\nfrom the standard text.\nOn hover, it changes its style to an underlined text to provide additional feedback to the user.\n\n### Usage\n\nYou can set the `Link` to be enabled or disabled.\n\nTo create a visual hierarchy in large lists of links, you can set the less important links as\n`Subtle` or the more important ones as `Emphasized`,\nby using the `design` property.\n\nIf the `href` property is set, the link behaves as the HTML\nanchor tag (`<a></a>`) and opens the specified URL in the given target frame (`target` property).\nTo specify where the linked content is opened, you can use the `target` property.\n\n### Responsive behavior\n\nIf there is not enough space, the text of the `Link` becomes truncated.\nIf the `wrappingType` property is set to `\"Normal\"`, the text is displayed\non several lines instead of being truncated.\n\n\n\n__Note:__ This is a UI5 Web Component! [Link UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Link) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<LinkDomRef, LinkClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is triggered either with a mouse/tap\nor by using the Enter key.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "altKey",
-                "type": "boolean",
-                "description": "Returns whether the \"ALT\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "ctrlKey",
-                "type": "boolean",
-                "description": "Returns whether the \"CTRL\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "metaKey",
-                "type": "boolean",
-                "description": "Returns whether the \"META\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "shiftKey",
-                "type": "boolean",
-                "description": "Returns whether the \"SHIFT\" key was pressed when the event was triggered."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "LinkAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls, is currently expanded or collapsed.\nAccepts the following string values: `true` or `false`.\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the input"
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "LinkAccessibleRole | \"Link\" | \"Button\"",
-            "value": [
-              {
-                "value": "\"Link\"",
-                "description": "Represents Default (link) ARIA role."
-              },
-              {
-                "value": "\"Button\"",
-                "description": "Represents the ARIA role \"button\"."
-              },
-              {
-                "value": "\"Link\""
-              },
-              {
-                "value": "\"Button\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the ARIA role of the component.\n\n**Note:** Use the <code>LinkAccessibleRole.Button</code> role in cases when navigation is not expected to occur and the href property is not defined.\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Link\""
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "LinkDesign | \"Default\" | \"Subtle\" | \"Emphasized\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "default type (no special styling)"
-              },
-              {
-                "value": "\"Subtle\"",
-                "description": "subtle type (appears as regular text, rather than a link)"
-              },
-              {
-                "value": "\"Emphasized\"",
-                "description": "emphasized type"
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Subtle\""
-              },
-              {
-                "value": "\"Emphasized\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component design.\n\n**Note:** Avaialble options are `Default`, `Subtle`, and `Emphasized`.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\n\n**Note:** When disabled, the click event cannot be triggered by the user.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "endIcon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon, displayed as graphical element within the component after the link's text.\nThe SAP-icons font provides numerous options.\n\n**Note:** Usage of icon-only link is not supported, the link must always have a text.\n\n**Note:** We recommend using аn icon in the beginning or the end only, and with text.\n\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
-        },
-        "href": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the component href.\n\n**Note:** Standard hyperlink behavior is supported."
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon, displayed as graphical element within the component before the link's text.\nThe SAP-icons font provides numerous options.\n\n**Note:** Usage of icon-only link is not supported, the link must always have a text.\n\n**Note:** We recommend using аn icon in the beginning or the end only, and with text.\n\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
-        },
-        "interactiveAreaSize": {
-          "type": {
-            "name": "enum",
-            "raw": "InteractiveAreaSize | \"Normal\" | \"Large\"",
-            "value": [
-              {
-                "value": "\"Normal\"",
-                "description": "The default target area size (the area taken by the component itself without any extra invisible touch area)."
-              },
-              {
-                "value": "\"Large\"",
-                "description": "Enlarged target area size (up to 24px in height) provides users with an enhanced dedicated space to interact with the component."
-              },
-              {
-                "value": "\"Normal\""
-              },
-              {
-                "value": "\"Large\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the target area size of the link:\n- **InteractiveAreaSize.Normal**: The default target area size.\n- **InteractiveAreaSize.Large**: The target area size is enlarged to 24px in height.\n\n**Note:**The property is designed to make links easier to activate and helps meet the WCAG 2.2 Target Size requirement. It is applicable only for the SAP Horizon themes.\n**Note:**To improve <code>ui5-link</code>'s reliability and usability, it is recommended to use the <code>InteractiveAreaSize.Large</code> value in scenarios where the <code>ui5-link</code> component is placed inside another interactive component, such as a list item or a table cell.\nSetting the <code>interactiveAreaSize</code> property to <code>InteractiveAreaSize.Large</code> increases the <code>ui5-link</code>'s invisible touch area. As a result, the user's intended one-time selection command is more likely to activate the desired <code>ui5-link</code>, with minimal chance of unintentionally activating the underlying component.\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Normal\""
-          }
-        },
-        "target": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the component target.\n\n**Notes:**\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `_search`\n\n**This property must only be used when the `href` property is set.**"
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Normal\" | WrappingType | \"None\"",
-            "value": [
-              {
-                "value": "\"Normal\""
-              },
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines how the text of a component will be displayed when there is not enough space.\n\n**Note:** By default the text will wrap. If \"None\" is set - the text will truncate.",
-          "defaultValue": {
-            "value": "\"Normal\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<LinkDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "endIcon",
-          "description": "Used to style the provided endIcon within the link"
-        },
-        {
-          "name": "icon",
-          "description": "Used to style the provided icon within the link"
-        }
-      ]
-    },
-    "List": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `List` component allows displaying a list of items, advanced keyboard\nhandling support for navigating between items, and predefined modes to improve the development efficiency.\n\nThe `List` is a container for the available list items:\n\n- `ListItemStandard`\n- `ListItemCustom`\n- `ListItemGroup`\n\nTo benefit from the built-in selection mechanism, you can use the available\nselection modes, such as\n`Single`, `Multiple` and `Delete`.\n\nAdditionally, the `List` provides header, footer, and customization for the list item separators.\n\n### Keyboard Handling\n\n#### Basic Navigation\nThe `List` provides advanced keyboard handling.\nWhen a list is focused the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Up] or [Down] - Navigates up and down the items\n- [Home] - Navigates to first item\n- [End] - Navigates to the last item\n\nThe user can use the following keyboard shortcuts to perform actions (such as select, delete),\nwhen the `selectionMode` property is in use:\n\n- [Space] - Select an item (if `type` is 'Active') when `selectionMode` is selection\n- [Delete] - Delete an item if `selectionMode` property is `Delete`\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n`import \"@ui5/webcomponents/dist/ListItemStandard.js\";` (for `ListItemStandard`)\n\n`import \"@ui5/webcomponents/dist/ListItemCustom.js\";` (for `ListItemCustom`)\n\n`import \"@ui5/webcomponents/dist/ListItemGroup.js\";` (for `ListItemGroup`)\n\n__Note:__ This is a UI5 Web Component! [List UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/List) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the component.\n\n**Note:** Use `ListItemStandard`, `ListItemCustom`, and `ListItemGroup` for the intended design.\n\n__Supported Node Type/s:__ `Array<ListItemBase | ListItemGroup>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the component header.\n\n**Note:** When `header` is set, the\n`headerText` property is ignored.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onItemClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListDomRef, ListItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when an item is activated, unless the item's `type` property\nis set to `Inactive`.\n\n**Note**: This event is not triggered by interactions with selection components such as the checkboxes and radio buttons,\nassociated with non-default `selectionMode` values, or if any other **interactive** component\n(such as a button or input) within the list item is directly clicked.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The clicked item."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onItemClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListDomRef, ListItemCloseEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `Close` button of any item is clicked\n\n**Note:** This event is only applicable to list items that can be closed (such as notification list items),\nnot to be confused with `item-delete`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "the item about to be closed."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onItemDelete": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListDomRef, ListItemDeleteEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the Delete button of any item is pressed.\n\n**Note:** A Delete button is displayed on each item,\nwhen the component `selectionMode` property is set to `Delete`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "the deleted item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onItemToggle": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListDomRef, ListItemToggleEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `Toggle` button of any item is clicked.\n\n**Note:** This event is only applicable to list items that can be toggled (such as notification group list items).\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "the toggled item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onLoadMore": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user scrolls to the bottom of the list.\n\n**Note:** The event is fired when the `growing='Scroll'` property is enabled.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMove": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListDomRef, MoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMoveOver": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListDomRef, MoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListDomRef, ListSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when selection is changed by user interaction\nin `Single`, `SingleStart`, `SingleEnd` and `Multiple` selection modes.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "previouslySelectedItems",
-                "type": "Array<ListItemBase>",
-                "description": "An array of the previously selected items."
-              },
-              {
-                "name": "selectedItems",
-                "type": "Array<ListItemBase>",
-                "description": "An array of the selected items."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ListAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines additional accessibility attributes on different areas of the component.\n\nThe accessibilityAttributes object has the following field:\n\n - **growingButton**: `growingButton.name`, `growingButton.description`.\n\n The accessibility attributes support the following values:\n\n- **name**: Defines the accessible ARIA name of the growing button.\nAccepts any string.\n\n- **description**: Defines the accessible ARIA description of the growing button.\nAccepts any string.\n\n **Note:** The `accessibilityAttributes` property is in an experimental state and is a subject to change.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that describe the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that label the component."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "ListAccessibleRole | \"List\" | \"Menu\" | \"Tree\" | \"ListBox\"",
-            "value": [
-              {
-                "value": "\"List\"",
-                "description": "Represents the ARIA role \"list\". (by default)"
-              },
-              {
-                "value": "\"Menu\"",
-                "description": "Represents the ARIA role \"menu\"."
-              },
-              {
-                "value": "\"Tree\"",
-                "description": "Represents the ARIA role \"tree\"."
-              },
-              {
-                "value": "\"ListBox\"",
-                "description": "Represents the ARIA role \"listbox\"."
-              },
-              {
-                "value": "\"List\""
-              },
-              {
-                "value": "\"Menu\""
-              },
-              {
-                "value": "\"Tree\""
-              },
-              {
-                "value": "\"ListBox\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the accessible role of the component.",
-          "defaultValue": {
-            "value": "\"List\""
-          }
-        },
-        "footerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the footer text."
-        },
-        "growing": {
-          "type": {
-            "name": "enum",
-            "raw": "ListGrowingMode | \"Button\" | \"Scroll\" | \"None\"",
-            "value": [
-              {
-                "value": "\"Button\"",
-                "description": "Component's \"load-more\" is fired upon pressing a \"More\" button.\nat the bottom."
-              },
-              {
-                "value": "\"Scroll\"",
-                "description": "Component's \"load-more\" is fired upon scroll."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Component's growing is not enabled."
-              },
-              {
-                "value": "\"Button\""
-              },
-              {
-                "value": "\"Scroll\""
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines whether the component will have growing capability either by pressing a `More` button,\nor via user scroll. In both cases `load-more` event is fired.\n\n**Restrictions:** `growing=\"Scroll\"` is not supported for Internet Explorer,\non IE the component will fallback to `growing=\"Button\"`.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "growingButtonText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text that will be displayed inside the growing button.\n\n**Note:** If not specified a built-in text will be displayed.\n\n**Note:** This property takes effect if the `growing` property is set to the `Button`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**."
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the component header text.\n\n**Note:** If `header` is set this property is ignored."
-        },
-        "indent": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is indented.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the component would display a loading indicator over the list.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the loading indicator will show up for this component.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "noDataText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text that is displayed when the component contains no items."
-        },
-        "selectionMode": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | ListSelectionMode | \"Single\" | \"SingleStart\" | \"SingleEnd\" | \"SingleAuto\" | \"Multiple\" | \"Delete\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\"",
-                "description": "Default mode (no selection)."
-              },
-              {
-                "value": "\"Single\"",
-                "description": "Right-positioned single selection mode (only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleStart\"",
-                "description": "Left-positioned single selection mode (only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleEnd\"",
-                "description": "Selected item is highlighted but no selection element is visible\n(only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleAuto\"",
-                "description": "Selected item is highlighted and selection is changed upon arrow navigation\n(only one list item can be selected - this is always the focused item)."
-              },
-              {
-                "value": "\"Multiple\"",
-                "description": "Multi selection mode (more than one list item can be selected)."
-              },
-              {
-                "value": "\"Delete\"",
-                "description": "Delete mode (only one list item can be deleted via provided delete button)"
-              },
-              {
-                "value": "\"Single\""
-              },
-              {
-                "value": "\"SingleStart\""
-              },
-              {
-                "value": "\"SingleEnd\""
-              },
-              {
-                "value": "\"SingleAuto\""
-              },
-              {
-                "value": "\"Multiple\""
-              },
-              {
-                "value": "\"Delete\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the selection mode of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "separators": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | ListSeparator | \"All\" | \"Inner\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"All\"",
-                "description": "Separators between the items including the last and the first one."
-              },
-              {
-                "value": "\"Inner\"",
-                "description": "Separators between the items.\nNote: This enumeration depends on the theme."
-              },
-              {
-                "value": "\"None\"",
-                "description": "No item separators."
-              },
-              {
-                "value": "\"All\""
-              },
-              {
-                "value": "\"Inner\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the item separator style that is used.",
-          "defaultValue": {
-            "value": "\"All\""
-          }
-        },
-        "stickyHeader": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the List header is sticky or not.\nIf stickyHeader is set to true, then whenever you scroll the content or\nthe application, the header of the list will be always visible.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ListDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "growing-button",
-          "description": "Used to style the button, that is used for growing of the component"
-        },
-        {
-          "name": "growing-button-inner",
-          "description": "Used to style the button inner element"
-        }
-      ]
-    },
-    "ListItemCustom": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A component to be used as custom list item within the `List`\nthe same way as the standard `ListItemStandard`.\n\nThe component accepts arbitrary HTML content to allow full customization.\n\n__Note:__ This is a UI5 Web Component! [ListItemCustom UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ListItemCustom) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "deleteButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `Button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "onDetailClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListItemCustomDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ListItemAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text alternative of the component.\n\n**Note**: If not provided a default text alternative will be set, if present."
-        },
-        "highlight": {
-          "type": {
-            "name": "enum",
-            "raw": "Highlight | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "movable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the item is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "navigated": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
-            "value": [
-              {
-                "value": "\"Inactive\"",
-                "description": "Indicates the list item does not have any active feedback when item is pressed."
-              },
-              {
-                "value": "\"Active\"",
-                "description": "Indicates that the item is clickable via active feedback when item is pressed."
-              },
-              {
-                "value": "\"Detail\"",
-                "description": "Enables detail button of the list item that fires detail-click event."
-              },
-              {
-                "value": "\"Navigation\"",
-                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
-              },
-              {
-                "value": "\"Inactive\""
-              },
-              {
-                "value": "\"Active\""
-              },
-              {
-                "value": "\"Detail\""
-              },
-              {
-                "value": "\"Navigation\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
-          "defaultValue": {
-            "value": "\"Active\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ListItemCustomDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "checkbox",
-          "description": "Used to style the checkbox rendered when the list item is in multiple selection mode"
-        },
-        {
-          "name": "content",
-          "description": "Used to style the content area of the list item"
-        },
-        {
-          "name": "delete-button",
-          "description": "Used to style the button rendered when the list item is in delete mode"
-        },
-        {
-          "name": "detail-button",
-          "description": "Used to style the button rendered when the list item is of type detail"
-        },
-        {
-          "name": "native-li",
-          "description": "Used to style the main li tag of the list item"
-        },
-        {
-          "name": "radio",
-          "description": "Used to style the radio button rendered when the list item is in single selection mode"
-        }
-      ]
-    },
-    "ListItemGroup": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ListItemGroup` is a special list item, used only to create groups of list items.\n\nThis is the item to use inside a `List`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ListItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ListItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the <code>ui5-li-group</code>.\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
-        },
-        "onMove": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMoveOver": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "headerAccessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the header."
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text of the <code>ui5-li-group</code>."
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "WrappingType | \"None\" | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ExpandableText` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ListItemGroupDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "header",
-          "description": "Used to style the header item of the group"
-        },
-        {
-          "name": "title",
-          "description": "Used to style the title of the group header"
-        }
-      ]
-    },
-    "ListItemStandard": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ListItemStandard` represents the simplest type of item for a `List`.\n\nThis is a list item,\nproviding the most common use cases such as `text`,\n`image` and `icon`.\n\n__Note:__ This is a UI5 Web Component! [ListItemStandard UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ListItemStandard) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the custom formatted text of the component.\n\n**Note:** For optimal text wrapping and a consistent layout, it is strongly recommended to use the `text` property.\n\nUse the `default` slot only when custom formatting with HTML elements (e.g., `<b>`, `<i>`) is required.\nBe aware that wrapping (via `wrappingType=\"Normal\"`) may not function correctly with custom HTML content in the `default` slot.\n\nIf both `text` and `default` slot are used, the `text` property takes precedence.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "deleteButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `Button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "image": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "**Note:** While the slot allows option for setting custom avatar, to match the\ndesign guidelines, please use the `Avatar` with it's default size - S.\n\n**Note:** If bigger `Avatar` needs to be used, then the size of the\n`ListItemStandard` should be customized in order to fit.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"image\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onDetailClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ListItemStandardDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ListItemAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text alternative of the component.\nNote: If not provided a default text alternative will be set, if present."
-        },
-        "additionalText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `additionalText`, displayed in the end of the list item."
-        },
-        "additionalTextState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the state of the `additionalText`.\n\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "description": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the description displayed right under the item text, if such is present."
-        },
-        "highlight": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\" | Highlight",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `icon` source URI.\n\n**Note:**\nSAP-icons font provides numerous built-in icons. To find all the available icons, see the\n[Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "iconEnd": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the `icon` should be displayed in the beginning of the list item or in the end.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "movable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the item is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "navigated": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**."
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
-            "value": [
-              {
-                "value": "\"Inactive\"",
-                "description": "Indicates the list item does not have any active feedback when item is pressed."
-              },
-              {
-                "value": "\"Active\"",
-                "description": "Indicates that the item is clickable via active feedback when item is pressed."
-              },
-              {
-                "value": "\"Detail\"",
-                "description": "Enables detail button of the list item that fires detail-click event."
-              },
-              {
-                "value": "\"Navigation\"",
-                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
-              },
-              {
-                "value": "\"Inactive\""
-              },
-              {
-                "value": "\"Active\""
-              },
-              {
-                "value": "\"Detail\""
-              },
-              {
-                "value": "\"Navigation\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
-          "defaultValue": {
-            "value": "\"Active\""
-          }
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | WrappingType | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ExpandableText` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ListItemStandardDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "additional-text",
-          "description": "Used to style the additionalText of the list item"
-        },
-        {
-          "name": "checkbox",
-          "description": "Used to style the checkbox rendered when the list item is in multiple selection mode"
-        },
-        {
-          "name": "content",
-          "description": "Used to style the content area of the list item"
-        },
-        {
-          "name": "delete-button",
-          "description": "Used to style the button rendered when the list item is in delete mode"
-        },
-        {
-          "name": "description",
-          "description": "Used to style the description of the list item"
-        },
-        {
-          "name": "detail-button",
-          "description": "Used to style the button rendered when the list item is of type detail"
-        },
-        {
-          "name": "icon",
-          "description": "Used to style the icon of the list item"
-        },
-        {
-          "name": "native-li",
-          "description": "Used to style the main li tag of the list item"
-        },
-        {
-          "name": "radio",
-          "description": "Used to style the radio button rendered when the list item is in single selection mode"
-        },
-        {
-          "name": "title",
-          "description": "Used to style the title of the list item"
-        }
-      ]
-    },
-    "MediaGallery": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `MediaGallery` component allows the user to browse through multimedia items. Currently,\nthe supported items are images and videos. The items should be defined using the `MediaGalleryItem`\ncomponent.\n\nThe items are initially displayed as thumbnails. When the user selects a thumbnail, the corresponding item\nis displayed in larger size.\n\nThe component is responsive by default and adjusts the position of the menu with respect to viewport size,\nbut the application is able to further customize the layout via the provided API.\n\n### Keyboard Handling\nThe `MediaGallery` provides advanced keyboard handling.\n\nWhen the thumbnails menu is focused the following keyboard\nshortcuts allow the user to navigate through the thumbnail items:\n\n- [Up] or [Down] - Navigates up and down the items\n- [Home] - Navigates to first item\n- [End] - Navigates to the last item\n- [Space], [Enter] - Selects an item\n\n\n\n`import \"@ui5/webcomponents-fiori/dist/MediaGalleryItem.js\";`\n\n__Note:__ This is a UI5 Web Component! [MediaGallery UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/MediaGallery) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the component items.\n\n**Note:** Only one selected item is allowed.\n\n**Note:** Use the `MediaGalleryItem` component to define the desired items.\n\n__Supported Node Type/s:__ `Array<IMediaGalleryItem>`"
-        },
-        "onDisplayAreaClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MediaGalleryDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the display area is clicked.\nThe display area is the central area that contains\nthe enlarged content of the currently selected item.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onOverflowClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MediaGalleryDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the thumbnails overflow button is clicked.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MediaGalleryDomRef, MediaGallerySelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when selection is changed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "the selected item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "interactiveDisplayArea": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "If enabled, a `display-area-click` event is fired\nwhen the user clicks or taps on the display area.\n\nThe display area is the central area that contains\nthe enlarged content of the currently selected item.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "layout": {
-          "type": {
-            "name": "enum",
-            "raw": "MediaGalleryLayout | \"Auto\" | \"Vertical\" | \"Horizontal\"",
-            "value": [
-              {
-                "value": "\"Auto\"",
-                "description": "The layout is determined automatically."
-              },
-              {
-                "value": "\"Vertical\"",
-                "description": "Displays the layout as a vertical split between the thumbnails list and the selected image."
-              },
-              {
-                "value": "\"Horizontal\"",
-                "description": "Displays the layout as a horizontal split between the thumbnails list and the selected image."
-              },
-              {
-                "value": "\"Auto\""
-              },
-              {
-                "value": "\"Vertical\""
-              },
-              {
-                "value": "\"Horizontal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the layout of the component.",
-          "defaultValue": {
-            "value": "\"Auto\""
-          }
-        },
-        "menuHorizontalAlign": {
-          "type": {
-            "name": "enum",
-            "raw": "MediaGalleryMenuHorizontalAlign | \"Left\" | \"Right\"",
-            "value": [
-              {
-                "value": "\"Left\"",
-                "description": "Displays the menu on the left side of the target."
-              },
-              {
-                "value": "\"Right\"",
-                "description": "Displays the menu on the right side of the target."
-              },
-              {
-                "value": "\"Left\""
-              },
-              {
-                "value": "\"Right\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the horizontal alignment of the thumbnails menu\nvs. the central display area.",
-          "defaultValue": {
-            "value": "\"Left\""
-          }
-        },
-        "menuVerticalAlign": {
-          "type": {
-            "name": "enum",
-            "raw": "MediaGalleryMenuVerticalAlign | \"Top\" | \"Bottom\"",
-            "value": [
-              {
-                "value": "\"Top\"",
-                "description": "Displays the menu at the top of the reference control."
-              },
-              {
-                "value": "\"Bottom\"",
-                "description": "Displays the menu at the bottom of the reference control."
-              },
-              {
-                "value": "\"Top\""
-              },
-              {
-                "value": "\"Bottom\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the vertical alignment of the thumbnails menu\nvs. the central display area.",
-          "defaultValue": {
-            "value": "\"Bottom\""
-          }
-        },
-        "showAllThumbnails": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "If set to `true`, all thumbnails are rendered in a scrollable container.\nIf `false`, only up to five thumbnails are rendered, followed by\nan overflow button that shows the count of the remaining thumbnails.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<MediaGalleryDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "MediaGalleryItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `MediaGalleryItem` web component represents the items displayed in the\n`MediaGallery` web component.\n\n**Note:** `MediaGalleryItem` is not supported when used outside of `MediaGallery`.\n\n### Keyboard Handling\nThe `MediaGallery` provides advanced keyboard handling.\nWhen focused, the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Space] / [Enter] or [Return] - Trigger `ui5-click` event\n\n)\n\n__Note:__ This is a UI5 Web Component! [MediaGalleryItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/MediaGalleryItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "thumbnail": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content of the thumbnail.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"thumbnail\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in disabled state.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "layout": {
-          "type": {
-            "name": "enum",
-            "raw": "MediaGalleryItemLayout | \"Square\" | \"Wide\"",
-            "value": [
-              {
-                "value": "\"Square\"",
-                "description": "Recommended to use when the item contains an image.\n\nWhen a thumbnail is selected, it makes the corresponding enlarged content appear in a square display area."
-              },
-              {
-                "value": "\"Wide\"",
-                "description": "Recommended to use when the item contains video content.\n\nWhen a thumbnail is selected, it makes the corresponding enlarged content appear in a wide display area\n(stretched to fill all of the available width) for optimal user experiance."
-              },
-              {
-                "value": "\"Square\""
-              },
-              {
-                "value": "\"Wide\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the layout of the item container.",
-          "defaultValue": {
-            "value": "\"Square\""
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<MediaGalleryItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Menu": {
-      "package": "@ui5/webcomponents-react",
-      "description": "`Menu` component represents a hierarchical menu structure.\n\n### Structure\n\nThe `Menu` can hold two types of entities:\n\n- `MenuItem` components\n- `MenuSeparator` - used to separate menu items with a line\n\nAn arbitrary hierarchy structure can be represented by recursively nesting menu items.\n\n### Keyboard Handling\n\nThe `Menu` provides advanced keyboard handling.\nThe user can use the following keyboard shortcuts in order to navigate trough the tree:\n\n- `Arrow Up` / `Arrow Down` - Navigates up and down the menu items that are currently visible.\n- `Arrow Right`, `Space` or `Enter` - Opens a sub-menu if there are menu items nested\nin the currently clicked menu item.\n- `Arrow Left` or `Escape` - Closes the currently opened sub-menu.\n\nwhen there is `endContent` :\n- `Arrow Left` or `ArrowRight` - Navigate between the menu item actions and the menu item itself\n- `Arrow Up` / `Arrow Down` - Navigates up and down the currently visible menu items\n\n**Note:** If the text direction is set to Right-to-left (RTL), `Arrow Right` and `Arrow Left` functionality is swapped.\n\nApplication developers are responsible for ensuring that interactive elements placed in the `endContent` slot\nhave the correct accessibility behaviour, including their enabled or disabled states.\nThe menu does not manage these aspects when the menu item state changes.\n\n\n\n__Note:__ This is a UI5 Web Component! [Menu UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Menu) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of this component.\n\n**Note:** Use `MenuItem` and `MenuSeparator` for their intended design.\n\n__Supported Node Type/s:__ `Array<IMenuItem>`"
-        },
-        "onBeforeClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MenuDomRef, MenuBeforeCloseEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the menu is closed. This event can be cancelled, which will prevent the menu from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "escPressed",
-                "type": "boolean",
-                "description": "Indicates that `ESC` key has triggered the event."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onBeforeOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MenuDomRef, MenuBeforeOpenEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the menu is opened. This event can be cancelled, which will prevent the menu from opening.\n\n**Note:** Since 1.14.0 the event is also fired before a sub-menu opens.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The `ui5-menu-item` that triggers opening of the sub-menu or undefined when fired upon root menu opening."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MenuDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the menu is closed.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onItemClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MenuDomRef, MenuItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when an item is being clicked.\n\n**Note:** Since 1.17.0 the event is preventable, allowing the menu to remain open after an item is pressed.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The currently clicked menu item."
-              },
-              {
-                "name": "text",
-                "type": "string",
-                "description": "The text of the currently clicked menu item."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MenuDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the menu is opened.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text of the menu (displayed on mobile)."
-        },
-        "horizontalAlign": {
-          "type": {
-            "name": "enum",
-            "raw": "PopoverHorizontalAlign | \"Center\" | \"Start\" | \"End\" | \"Stretch\"",
-            "value": [
-              {
-                "value": "\"Center\"",
-                "description": "Popover is centered."
-              },
-              {
-                "value": "\"Start\"",
-                "description": "Popover is aligned with the start of the target."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Popover is aligned with the end of the target."
-              },
-              {
-                "value": "\"Stretch\"",
-                "description": "Popover is stretched."
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Stretch\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the horizontal alignment of the menu relative to its opener control.",
-          "defaultValue": {
-            "value": "\"Start\""
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if a loading indicator would be displayed inside the corresponding ui5-menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the loading indicator will be displayed inside the corresponding ui5-menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if the menu is open.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "opener": {
-          "type": {
-            "name": "string | HTMLElement"
-          },
-          "required": false,
-          "description": "Defines the ID or DOM Reference of the element at which the menu is shown.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**."
-        },
-        "placement": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Start\" | \"End\" | PopoverPlacement | \"Top\" | \"Bottom\"",
-            "value": [
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Start\"",
-                "description": "Popover will be placed at the start of the reference element."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Popover will be placed at the end of the reference element."
-              },
-              {
-                "value": "\"Top\"",
-                "description": "Popover will be placed at the top of the reference element."
-              },
-              {
-                "value": "\"Bottom\"",
-                "description": "Popover will be placed at the bottom of the reference element."
-              },
-              {
-                "value": "\"Top\""
-              },
-              {
-                "value": "\"Bottom\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines on which side the component is placed at.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Bottom\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<MenuDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "MenuItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "`MenuItem` is the item to use inside a `Menu`.\nAn arbitrary hierarchy structure can be represented by recursively nesting menu items.\n\n### Usage\n\n`MenuItem` represents a node in a `Menu`. The menu itself is rendered as a list,\nand each `MenuItem` is represented by a list item in that list. Therefore, you should only use\n`MenuItem` directly in your apps. The `ListItemStandard` list item is internal for the list, and not intended for public use.\n\n\n\n__Note:__ This is a UI5 Web Component! [MenuItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MenuItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of this component.\n\n**Note:** The slot can hold menu item and menu separator items.\n\nIf there are items added to this slot, an arrow will be displayed at the end\nof the item in order to indicate that there are items added. In that case components added\nto `endContent` slot or `additionalText` content will not be displayed.\n\nThe priority of what will be displayed at the end of the menu item is as follows:\nsub-menu arrow (if there are items added in `items` slot) -> components added in `endContent` -> text set to `additionalText`.\n\n__Supported Node Type/s:__ `Array<IMenuItem>`"
-        },
-        "deleteButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `Button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "endContent": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the components that should be displayed at the end of the menu item.\n\n**Note:** It is highly recommended to slot only components of type `Button`,`Link`\nor `Icon` in order to preserve the intended design. If there are components added to this slot,\nand there is text set in `additionalText`, it will not be displayed. If there are items added to `items` slot,\nnether `additionalText` nor components added to this slot would be displayed.\n\nThe priority of what will be displayed at the end of the menu item is as follows:\nsub-menu arrow (if there are items added in `items` slot) -> components added in `endContent` -> text set to `additionalText`.\n\nApplication developers are responsible for ensuring that interactive elements placed in the `endContent` slot\nhave the correct accessibility behaviour, including their enabled or disabled states.\nThe menu does not manage these aspects when the menu item state changes.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"endContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onBeforeClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MenuItemDomRef, MenuBeforeCloseEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the menu is closed. This event can be cancelled, which will prevent the menu from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "escPressed",
-                "type": "boolean",
-                "description": "Indicates that `ESC` key has triggered the event."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onBeforeOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MenuItemDomRef, MenuBeforeOpenEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the menu is opened. This event can be cancelled, which will prevent the menu from opening.\n\n**Note:** Since 1.14.0 the event is also fired before a sub-menu opens.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The menu item that triggers opening of the sub-menu or undefined when fired upon root menu opening."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onCheck": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MenuItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when an item is checked or unchecked.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MenuItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the menu is closed.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onDetailClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MenuItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MenuItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the menu is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "MenuItemAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaKeyShortcuts**: Indicated the availability of a keyboard shortcuts defined for the menu item.\n\n- **role**: Defines the role of the menu item. If not set, menu item will have default role=\"menuitem\".\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.7.0](https://github.com/UI5/webcomponents/releases/tag/v1.7.0) of **@ui5/webcomponents**."
-        },
-        "additionalText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `additionalText`, displayed in the end of the menu item.\n\n**Note:** The additional text will not be displayed if there are items added in `items` slot or there are\ncomponents added to `endContent` slot.\n\nThe priority of what will be displayed at the end of the menu item is as follows:\nsub-menu arrow (if there are items added in `items` slot) -> components added in `endContent` -> text set to `additionalText`.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents**."
-        },
-        "checked": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether menu item is in checked state.\n\n**Note:** checked state is only taken into account when menu item is added to menu item group\nwith `checkMode` other than `None`.\n\n**Note:** A checked menu item has a checkmark displayed at its end.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether menu item is in disabled state.\n\n**Note:** A disabled menu item is noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "highlight": {
-          "type": {
-            "name": "enum",
-            "raw": "Highlight | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\n**Example:**\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the loading indicator will be displayed inside the corresponding menu popover.\n\n**Note:** If set to `true` a busy indicator component will be displayed into the related one to the current menu item sub-menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the loading indicator will be displayed inside the corresponding menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "navigated": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tree item."
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tooltip for the menu item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
-            "value": [
-              {
-                "value": "\"Inactive\"",
-                "description": "Indicates the list item does not have any active feedback when item is pressed."
-              },
-              {
-                "value": "\"Active\"",
-                "description": "Indicates that the item is clickable via active feedback when item is pressed."
-              },
-              {
-                "value": "\"Detail\"",
-                "description": "Enables detail button of the list item that fires detail-click event."
-              },
-              {
-                "value": "\"Navigation\"",
-                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
-              },
-              {
-                "value": "\"Inactive\""
-              },
-              {
-                "value": "\"Active\""
-              },
-              {
-                "value": "\"Detail\""
-              },
-              {
-                "value": "\"Navigation\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
-          "defaultValue": {
-            "value": "\"Active\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<MenuItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "MenuItemGroup": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `MenuItemGroup` component represents a group of items designed for use inside a `Menu`.\nItems belonging to the same group should be wrapped by a `MenuItemGroup`.\nEach group can have an `checkMode` property, which defines the check mode for the items within the group.\nThe possible values for `checkMode` are:\n- 'None' (default) - no items can be checked\n- 'Single' - Only one item can be checked at a time\n- 'Multiple' - Multiple items can be checked simultaneously\n\n**Note:** If the `checkMode` property is set to 'Single', only one item can remain checked at any given time.\nIf multiple items are marked as checked, the last checked item will take precedence.\n\n### Usage\n\n`MenuItemGroup` represents a collection of `MenuItem` components that can have the same check mode.\nThe items are addeed to the group's `items` slot.\n\n\n\n__Note:__ This is a UI5 Web Component! [MenuItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MenuItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of this component.\n**Note:** The slot can hold any combination of components of type `MenuItem` or `MenuSeparator` or both.\n\n__Supported Node Type/s:__ `Array<IMenuItem>`"
-        },
-        "checkMode": {
-          "type": {
-            "name": "enum",
-            "raw": "MenuItemGroupCheckMode | \"None\" | \"Single\" | \"Multiple\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "default type (items in a group cannot be checked)"
-              },
-              {
-                "value": "\"Single\"",
-                "description": "Single item check mode (only one item in a group can be checked at a time)"
-              },
-              {
-                "value": "\"Multiple\"",
-                "description": "Multiple items check mode (multiple items in a group can be checked at a time)"
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Single\""
-              },
-              {
-                "value": "\"Multiple\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component's check mode.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<MenuItemGroupDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "MenuSeparator": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `MenuSeparator` represents a horizontal line to separate menu items inside a `Menu`.\n\n__Note:__ This is a UI5 Web Component! [MenuSeparator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MenuSeparator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<MenuSeparatorDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "MessageStrip": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The ui5-message-strip component allows for the embedding of application-related messages.\nIt supports four semantic designs, each with its own color and icon: \"Information\", \"Positive\", \"Critical\", and \"Negative\".\nAdditionally, users can choose from two color sets (\"ColorSet1\" and \"ColorSet2\"), each containing 10 predefined color schemes.\nEach message shows a \"Close\" button, so that it can be removed from the UI, if needed.\n\n### Usage\n\nFor the `MessageStrip` component, you can define whether it displays\nan icon in the beginning and a close button. Moreover, its size and background\ncan be controlled with CSS.\n\n### Keyboard Handling\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [MessageStrip UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MessageStrip) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "icon": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content to be displayed as graphical element within the component.\n\n**Note:** If no icon is given, the default icon for the component type will be used.\nThe SAP-icons font provides numerous options.\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html).\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MessageStripDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the close button is pressed either with a\nclick/tap or by using the Enter or Space key.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "colorScheme": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the color scheme of the component.\nThere are 10 predefined schemes.\nTo use one you can set a number from `\"1\"` to `\"10\"`. The `colorScheme` `\"1\"` will be set by default.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"1\""
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "MessageStripDesign | \"Information\" | \"Positive\" | \"Negative\" | \"Critical\" | \"ColorSet1\" | \"ColorSet2\"",
-            "value": [
-              {
-                "value": "\"Information\"",
-                "description": "Message should be just an information"
-              },
-              {
-                "value": "\"Positive\"",
-                "description": "Message is a success message"
-              },
-              {
-                "value": "\"Negative\"",
-                "description": "Message is an error"
-              },
-              {
-                "value": "\"Critical\"",
-                "description": "Message is a warning"
-              },
-              {
-                "value": "\"ColorSet1\"",
-                "description": "Message uses custom color set 1"
-              },
-              {
-                "value": "\"ColorSet2\"",
-                "description": "Message uses custom color set 2"
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"ColorSet1\""
-              },
-              {
-                "value": "\"ColorSet2\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component type.",
-          "defaultValue": {
-            "value": "\"Information\""
-          }
-        },
-        "hideCloseButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the MessageStrip renders close button.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the MessageStrip will show an icon in the beginning.\nYou can directly provide an icon with the `icon` slot. Otherwise, the default icon for the type will be used.\n\n * **Note:** If <code>MessageStripDesign.ColorSet1</code> or <code>MessageStripDesign.ColorSet2</code> value is set to the <code>design</code> property, default icon will not be presented.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<MessageStripDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "MultiComboBox": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `MultiComboBox` component consists of a list box with items and a text field allowing the user to either type a value directly into the text field, or choose from the list of existing items.\n\nThe drop-down list is used for selecting and filtering values, it enables users to select one or more options from a predefined list. The control provides an editable input field to filter the list, and a dropdown arrow to expand/collapse the list of available options.\nThe options in the list have checkboxes that permit multi-selection. Entered values are displayed as tokens.\n### Structure\nThe `MultiComboBox` consists of the following elements:\n\n-  Tokenizer - a list of tokens with selected options.\n-  Input field - displays the selected option/s as token/s. Users can type to filter the list.\n-  Drop-down arrow - expands\\collapses the option list.\n-  Option list - the list of available options.\n\n### Keyboard Handling\n\nThe `MultiComboBox` provides advanced keyboard handling.\n\n#### Picker\nIf the `MultiComboBox` is focused,\nyou can open or close the drop-down by pressing [F4], [Alt] + [Up] or [Alt] + [Down] keys.\nOnce the drop-down is opened, you can use the `UP` and `DOWN` arrow keys\nto navigate through the available options and select one by pressing the `Space` or `Enter` keys.\n[Ctrl]+[Alt]+[F8] or [Command]+[Option]+[F8] - Focuses the first link in the value state message, if available. Pressing [Tab] moves the focus to the next link in the value state message, or closes the value state message if there are no more links.\n\n#### Tokens\n\n-  Left/Right arrow keys - moves the focus selection form the currently focused token to the previous/next one (if available).\n-  Delete -  deletes the token and focuses the previous token.\n-  Backspace -  deletes the token and focus the next token.\n\n\n\n__Note:__ This is a UI5 Web Component! [MultiComboBox UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MultiComboBox) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the component items.\n\n__Supported Node Type/s:__ `Array<IMultiComboBoxItem>`"
-        },
-        "icon": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed in the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
-        },
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the dropdown is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the component changes at each keystroke or clear icon is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the dropdown is opened.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, MultiComboBoxSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when selection is changed by user interaction.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "items",
-                "type": "Array<IMultiComboBoxItem>",
-                "description": "an array of the selected items."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onValueStateChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiComboBoxDomRef, MultiComboBoxValueStateChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the value state of the component is updated internally.\nThe event is preventable, meaning that if it's default action is\nprevented, the component will not update the value state.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valueState",
-                "type": "string",
-                "description": "The new `valueState` that will be set."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "filter": {
-          "type": {
-            "name": "enum",
-            "raw": "ComboBoxFilter | \"StartsWithPerTerm\" | \"StartsWith\" | \"Contains\" | \"None\"",
-            "value": [
-              {
-                "value": "\"StartsWithPerTerm\"",
-                "description": "Defines filtering by first symbol of each word of item's text."
-              },
-              {
-                "value": "\"StartsWith\"",
-                "description": "Defines filtering by starting symbol of item's text."
-              },
-              {
-                "value": "\"Contains\"",
-                "description": "Defines contains filtering."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Removes any filtering applied while typing"
-              },
-              {
-                "value": "\"StartsWithPerTerm\""
-              },
-              {
-                "value": "\"StartsWith\""
-              },
-              {
-                "value": "\"Contains\""
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the filter type of the component.",
-          "defaultValue": {
-            "value": "\"StartsWithPerTerm\""
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether a loading indicator should be shown in the picker.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n**Note:** When the component is used inside a form element,\nthe value is sent as the first element in the form data, even if it's empty.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
-        },
-        "noTypeahead": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the value will be autcompleted to match an item\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "noValidation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the user input will be prevented, if no matching item has been found",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the items picker is open.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selectedValues": {
-          "type": {
-            "name": "string[]"
-          },
-          "required": false,
-          "description": "Defines the values of the selected items.\n\nUse this property to programmatically select items by their `value` property.\nEach string in the array should match the `value` attribute of a `MultiComboBoxItem`.\n\n**Note:** If an item doesn't have a `value` attribute set, it cannot be selected via this property.\n\n**Note:** The recommended approach is to set the `value` property on each `MultiComboBoxItem`\nand use `selectedValues` for programmatic selection. The `selected` property on items is\ndeprecated and should not be used together with `selectedValues`.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "[]"
-          }
-        },
-        "showClearIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the clear icon of the multi-combobox will be shown.\n\n**Note:** Available since [v1.20.1](https://github.com/UI5/webcomponents/releases/tag/v1.20.1) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showSelectAll": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines if the select all checkbox is visible on top of suggestions.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<MultiComboBoxDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "token-\\{index\\}",
-          "description": "Used to style each token(where `token-0` corresponds to the first item)"
-        }
-      ]
-    },
-    "MultiComboBoxItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `MultiComboBoxItem` represents the item for a `MultiComboBox`.\n\n__Note:__ This is a UI5 Web Component! [MultiComboBoxItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MultiComboBoxItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "additionalText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the additional text of the component."
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.\n@deprecated Set the `value` property on items and use the `selectedValues` property on the parent `ui5-multi-combobox` instead for programmatic selection.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the component."
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component.\n\nUse this property to associate a unique identifier with the item,\nseparate from the display text. This enables selecting items\nprogrammatically via `selectedValues` on the parent MultiComboBox.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<MultiComboBoxItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "MultiComboBoxItemGroup": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `MultiComboBoxItemGroup` is type of suggestion item,\nthat can be used to split the `MultiComboBox` suggestions into groups.\n\n__Note:__ This is a UI5 Web Component! [MultiComboBoxItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MultiComboBoxItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the <code>ui5-mcb-item-group</code>.\n\n__Supported Node Type/s:__ `Array<MultiComboBoxItem>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
-        },
-        "onMove": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiComboBoxItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMoveOver": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiComboBoxItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "headerAccessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the header."
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text of the <code>ui5-li-group</code>."
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "WrappingType | \"None\" | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ExpandableText` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<MultiComboBoxItemGroupDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "header",
-          "description": "Used to style the header item of the group"
-        },
-        {
-          "name": "title",
-          "description": "Used to style the title of the group header"
-        }
-      ]
-    },
-    "MultiInput": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A `MultiInput` field allows the user to enter multiple values, which are displayed as `Token`.\n\nUser can choose interaction for creating tokens.\nFiori Guidelines say that user should create tokens when:\n\n- Type a value in the input and press enter or focus out the input field (`change` event is fired)\n- Move between suggestion items (`selection-change` event is fired)\n- Clicking on a suggestion item (`selection-change` event is fired if the clicked item is different than the current value. Also `change` event is fired )\n\n\n\n__Note:__ This is a UI5 Web Component! [MultiInput UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/MultiInput) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the suggestion items.\n\n**Note:** The suggestions would be displayed only if the `showSuggestions`\nproperty is set to `true`.\n\n**Note:** The `<SuggestionItem>`, `<SuggestionItemGroup>` and `SuggestionItemCustom` are recommended to be used as suggestion items.\n\n__Supported Node Type/s:__ `Array<IInputSuggestionItem>`"
-        },
-        "icon": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed in the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
-        },
-        "tokens": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the component tokens.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"tokens\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IToken>`"
-        },
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n**Note:** If the component has `suggestionItems`,\nthe `valueStateMessage` would be displayed as part of the same popover, if used on desktop, or dialog - on phone.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the suggestions picker is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the component changes at each keystroke,\nand when a suggestion item has been selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the suggestions picker is open.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSelect": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when some text has been selected.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiInputDomRef, InputSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user navigates to a suggestion item via the ARROW keys,\nas a preview, before the final selection.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The previewed suggestion item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onTokenDelete": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiInputDomRef, MultiInputTokenDeleteEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when tokens are being deleted.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "tokens",
-                "type": "Array",
-                "description": "An array containing the deleted tokens."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onValueHelpTrigger": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<MultiInputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value help icon is pressed\nand F4 or ALT/OPTION + ARROW_UP/ARROW_DOWN keyboard keys are used.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the input."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "filter": {
-          "type": {
-            "name": "enum",
-            "raw": "InputSuggestionsFilter | \"StartsWithPerTerm\" | \"StartsWith\" | \"Contains\" | \"None\"",
-            "value": [
-              {
-                "value": "\"StartsWithPerTerm\"",
-                "description": "Defines filtering by first symbol of each word of item's text."
-              },
-              {
-                "value": "\"StartsWith\"",
-                "description": "Defines filtering by starting symbol of item's text."
-              },
-              {
-                "value": "\"Contains\"",
-                "description": "Defines contains filtering."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Removes any filtering applied while typing"
-              },
-              {
-                "value": "\"StartsWithPerTerm\""
-              },
-              {
-                "value": "\"StartsWith\""
-              },
-              {
-                "value": "\"Contains\""
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the filter type of the component.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "maxlength": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Sets the maximum number of characters available in the input field.\n\n**Note:** This property is not compatible with the ui5-input type InputType.Number. If the ui5-input type is set to Number, the maxlength value is ignored."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n**Note:** When the component is used inside a form element,\nthe value is sent as the first element in the form data, even if it's empty."
-        },
-        "noTypeahead": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the value will be autcompleted to match an item\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the suggestions picker is open.\nThe picker will not open if the `showSuggestions` property is set to `false`, the input is disabled or the input is readonly.\nThe picker will close automatically and `close` event will be fired if the input is not in the viewport.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showClearIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showSuggestions": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should show suggestions, if such are present.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showValueHelpIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether a value help icon will be visualized in the end of the input.\nPressing the icon will fire `value-help-trigger` event.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "InputType | \"Text\" | \"Email\" | \"Number\" | \"Password\" | \"Tel\" | \"URL\" | \"Search\"",
-            "value": [
-              {
-                "value": "\"Text\"",
-                "description": "Defines a one-line text input field:"
-              },
-              {
-                "value": "\"Email\"",
-                "description": "Used for input fields that must contain an e-mail address."
-              },
-              {
-                "value": "\"Number\"",
-                "description": "Defines a numeric input field."
-              },
-              {
-                "value": "\"Password\"",
-                "description": "Defines a password field."
-              },
-              {
-                "value": "\"Tel\"",
-                "description": "Used for input fields that should contain a telephone number."
-              },
-              {
-                "value": "\"URL\"",
-                "description": "Used for input fields that should contain a URL address."
-              },
-              {
-                "value": "\"Search\"",
-                "description": "Used for input fields that should contain a search term."
-              },
-              {
-                "value": "\"Text\""
-              },
-              {
-                "value": "\"Email\""
-              },
-              {
-                "value": "\"Number\""
-              },
-              {
-                "value": "\"Password\""
-              },
-              {
-                "value": "\"Tel\""
-              },
-              {
-                "value": "\"URL\""
-              },
-              {
-                "value": "\"Search\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the HTML type of the component.\n\n**Notes:**\n\n- The particular effect of this property differs depending on the browser\nand the current language settings, especially for type `Number`.\n- The property is mostly intended to be used with touch devices\nthat use different soft keyboard layouts depending on the given input type.",
-          "defaultValue": {
-            "value": "\"Text\""
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<MultiInputDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "clear-icon",
-          "description": "Used to style the clear icon, which can be pressed to clear user input text"
-        },
-        {
-          "name": "input",
-          "description": "Used to style the native input element"
-        },
-        {
-          "name": "root",
-          "description": "Used to style the root DOM element of the Input component"
-        }
-      ]
-    },
-    "NavigationLayout": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `NavigationLayout` is a container component that can be used to\ncreate a layout with a header, a side navigation and a content area.\n\n### Usage\n\nUse the `NavigationLayout` to create whole screen of an application with vertical navigation.\n\n### Responsive Behavior\n\nOn larger screens with a width of 600px or more, excluding mobile phone devices, the side navigation is visible\nby default and can be expanded or collapsed using the `mode` property.\nOn mobile phone devices and screens with a width of 599px or less, the side navigation is hidden by\ndefault and can be displayed using the `mode` property.\n\n\n\n__Note:__ This is a UI5 Web Component! [NavigationLayout UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/NavigationLayout) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "sideContent": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the side content.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"sideContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<SideNavigation>`"
-        },
-        "mode": {
-          "type": {
-            "name": "enum",
-            "raw": "NavigationLayoutMode | \"Auto\" | \"Collapsed\" | \"Expanded\"",
-            "value": [
-              {
-                "value": "\"Auto\"",
-                "description": "Automatically calculates the navigation layout mode based on the screen width.\n`Collapsed` on small screens (screen width of 599px or less) and `Expanded` on larger screens (screen width of 600px or more)."
-              },
-              {
-                "value": "\"Collapsed\"",
-                "description": "Collapsed side navigation."
-              },
-              {
-                "value": "\"Expanded\"",
-                "description": "Expanded side navigation."
-              },
-              {
-                "value": "\"Auto\""
-              },
-              {
-                "value": "\"Collapsed\""
-              },
-              {
-                "value": "\"Expanded\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Specifies the navigation layout mode.",
-          "defaultValue": {
-            "value": "\"Auto\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<NavigationLayoutDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "isSideCollapsed",
-          "description": "Gets whether the side navigation is collapsed.",
-          "params": [],
-          "returns": {
-            "type": "boolean"
-          }
-        }
-      ]
-    },
-    "NotificationList": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `NotificationList` web component represents\na container for `NotificationListGroupItem` and `NotificationListItem`.\n\n### Keyboard Handling\n\n#### Basic Navigation\nThe `NotificationList` provides advanced keyboard handling.\nWhen a list is focused the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Up] or [Left] - Navigates up the items\n- [Down] or [Right] - Navigates down the items\n- [Home] - Navigates to first item\n- [End] - Navigates to the last item\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [NotificationList UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/NotificationList) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the component.\n\n__Supported Node Type/s:__ `Array<NotificationListItemBase>`"
-        },
-        "onItemClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<NotificationListDomRef, NotificationItemEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when an item is clicked.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The clicked item."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onItemClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<NotificationListDomRef, NotificationItemEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `Close` button of any item is clicked.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "the item about to be closed."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onItemToggle": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<NotificationListDomRef, NotificationItemEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when an item is toggled.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "the toggled item."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "noDataText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text that is displayed when the component contains no items."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<NotificationListDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "NotificationListGroupItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `NotificationListGroupItem` is a special type of list item,\nthat unlike others can group items within self, usually `NotificationListItem` items.\n\nThe component consists of:\n\n- `Toggle` button to expand and collapse the group\n- `TitleText` to entitle the group\n- Items of the group\n\n### Usage\nThe component should be used inside a `NotificationList`.\n\n### Keyboard Handling\nThe `NotificationListGroupItem` provides advanced keyboard handling.\nThis component provides fast navigation when the header is focused using the following keyboard shortcuts:\n\n- [Space] - toggles expand / collapse of the group\n- [Plus] - expands the group\n- [Minus] - collapses the group\n- [Right] - expands the group\n- [Left] - collapses the group\n\n\n\n__Note:__ This is a UI5 Web Component! [NotificationListGroupItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/NotificationListGroupItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the `NotificationListGroupItem`,\nusually `NotificationListItem` items.\n\n__Supported Node Type/s:__ `Array<NotificationListItem>`"
-        },
-        "onLoadMore": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<NotificationListGroupItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when additional items are requested.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onToggle": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<NotificationListGroupItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `NotificationListGroupItem` is expanded/collapsed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "collapsed": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the group is collapsed or expanded.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "growing": {
-          "type": {
-            "name": "enum",
-            "raw": "NotificationListGrowingMode | \"Button\" | \"None\"",
-            "value": [
-              {
-                "value": "\"Button\"",
-                "description": "Component's \"load-more\" is fired upon pressing a \"More\" button.\nat the bottom."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Component's growing is not enabled."
-              },
-              {
-                "value": "\"Button\""
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines whether the component will have growing capability by pressing a `More` button.\nWhen button is pressed `load-more` event will be fired.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if a busy indicator would be displayed over the item.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the busy indicator will show up for this component.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "read": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the `notification` is new or has been already read.\n\n**Note:** if set to `false` the `titleText` has bold font,\nif set to true - it has a normal font.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `titleText` of the item."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<NotificationListGroupItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "NotificationListItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `NotificationListItem` is a type of list item, meant to display notifications.\n\nThe component has a rich set of various properties that allows the user to set `avatar`, `menu`, `titleText`, descriptive `content`\nand `footnotes` to fully describe a notification.\n\nThe user can:\n\n- display a `Close` button\n- can control whether the `titleText` and `description` should wrap or truncate\nand display a `ShowMore` button to switch between less and more information\n- add actions by using the `ui5-menu` component\n\n**Note:** Adding custom actions by using the `ui5-notification-action` component is deprecated as of version 2.0!\n\n### Usage\nThe component should be used inside a `NotificationList`.\n\n### Keyboard Handling\n\n#### Basic Navigation\nThe user can use the following keyboard shortcuts to perform actions (such as select, delete):\n\n- [Enter] - select an item (trigger \"item-click\" event)\n- [Delete] - close an item (trigger \"item-close\" event)\n\n#### Fast Navigation\nThis component provides a fast navigation using the following keyboard shortcuts:\n\n- [Shift] + [Enter] - 'More'/'Less' link will be triggered\n- [Shift] + [F10] - 'Menu' (Actions) button will be triggered (clicked)\n\n\n\n__Note:__ This is a UI5 Web Component! [NotificationListItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/NotificationListItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "avatar": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the avatar, displayed in the `NotificationListItem`.\n\n**Note:** Consider using the `ui5-avatar` to display icons, initials or images.\n\n**Note:** In order to be complaint with the UX guidlines and for best experience,\nwe recommend using avatars with 2rem X 2rem in size (32px X 32px). In case you are using the `ui5-avatar`\nyou can set its `size` property to `XS` to get the required size - `<ui5-avatar size=\"XS\"></ui5-avatar>`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"avatar\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the `NotificationListItem`,\nusually a description of the notification.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "footnotes": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the elements, displayed in the footer of the of the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footnotes\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "menu": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the menu, displayed in the `NotificationListItem`.\n\n**Note:** Use this for implementing actions.\n\n**Note:** Should be used instead `u5-notification-action`, which is deprecated as of version 2.0.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"menu\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<NotificationListItemDomRef, NotificationListItemCloseEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `Close` button is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "the closed item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": false
-          }
-        },
-        "importance": {
-          "type": {
-            "name": "enum",
-            "raw": "NotificationListItemImportance | \"Standard\" | \"Important\"",
-            "value": [
-              {
-                "value": "\"Standard\""
-              },
-              {
-                "value": "\"Important\""
-              },
-              {
-                "value": "\"Standard\""
-              },
-              {
-                "value": "\"Important\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the `Important` label of the item.",
-          "defaultValue": {
-            "value": "\"Standard\""
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if a busy indicator would be displayed over the item.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the busy indicator will show up for this component.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "read": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the `notification` is new or has been already read.\n\n**Note:** if set to `false` the `titleText` has bold font,\nif set to true - it has a normal font.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showClose": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the `Close` button would be displayed.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "state": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the status indicator of the item.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `titleText` of the item."
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | WrappingType | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines if the `titleText` and `description` should wrap,\nthey truncate by default.\n\n**Note:** by default the `titleText` and `description`,\nand a `ShowMore/Less` button would be displayed.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<NotificationListItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "title-text",
-          "description": "Used to style the titleText of the notification list item"
-        }
-      ]
-    },
-    "Option": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Option` component defines the content of an option in the `Select`.\n\n\n\n__Note:__ This is a UI5 Web Component! [Option UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Option) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "additionalText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `additionalText`, displayed in the end of the option."
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `icon` source URI.\n\n**Note:**\nSAP-icons font provides numerous built-in icons. To find all the available icons, see the\n[Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.\n@deprecated since 2.20.0, please use the parent Select's `value` property instead.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the option.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the `Select` inside an HTML Form element when this component is selected.\nFor more information on HTML Form support, see the `name` property of `Select`."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<OptionDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "OptionCustom": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `OptionCustom` component defines a custom content of an option in the `Select`.\nA component to be the same way as the standard `Option`.\nThe component accepts arbitrary HTML content to allow full customization.\n\n\n\n__Note:__ This is a UI5 Web Component! [OptionCustom UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/OptionCustom) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "displayText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text, displayed inside the `Select` input filed\nwhen the option gets selected."
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the option."
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the `Select` inside an HTML Form element when this component is selected.\nFor more information on HTML Form support, see the `name` property of `Select`."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<OptionCustomDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Page": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Page` is a container component that holds one whole screen of an application.\nThe page has three distinct areas that can hold content - a header, content area and a footer.\n### Structure\n#### Header\nThe top most area of the page is occupied by the header. The standard header includes a navigation button and a title.\n#### Content\nThe content occupies the main part of the page. Only the content area is scrollable by default.\nThis can be prevented by setting `noScrolling` to `true`.\n#### Footer\nThe footer is optional and occupies the part above the bottom part of the content. Alternatively, the footer can be fixed at the bottom of the page by enabling the `fixedFooter` property.\n\n**Note:** `Page` occipues the whole available space of its parent. In order to achieve the intended design you have to make sure\nthat there is enough space for the `Page` to be rendered.\n**Note:** In order for the `Page` to be displayed, the parent element should have fixed height.\n\n\n\n__Note:__ This is a UI5 Web Component! [Page UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/Page) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content HTML Element.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "footer": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the footer HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "backgroundDesign": {
-          "type": {
-            "name": "enum",
-            "raw": "PageBackgroundDesign | \"List\" | \"Solid\" | \"Transparent\"",
-            "value": [
-              {
-                "value": "\"List\"",
-                "description": "Page background color when a List is set as the Page content."
-              },
-              {
-                "value": "\"Solid\"",
-                "description": "A solid background color dependent on the theme."
-              },
-              {
-                "value": "\"Transparent\"",
-                "description": "Transparent background for the page."
-              },
-              {
-                "value": "\"List\""
-              },
-              {
-                "value": "\"Solid\""
-              },
-              {
-                "value": "\"Transparent\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the background color of the `Page`.\n\n**Note:** When a ui5-list is placed inside the page, we recommend using “List” to ensure better color contrast.",
-          "defaultValue": {
-            "value": "\"Solid\""
-          }
-        },
-        "fixedFooter": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the footer is fixed at the very bottom of the page.\n\n**Note:** When set to true the footer is fixed at the very bottom of the page, otherwise it floats over the content with a slight offset from the bottom.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideFooter": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the footer visibility.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "noScrolling": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Disables vertical scrolling of page content.\nIf set to true, there will be no vertical scrolling at all.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<PageDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "content",
-          "description": "Used to style the content section of the component"
-        }
-      ]
-    },
-    "Panel": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Panel` component is a container which has a header and a\ncontent area and is used\nfor grouping and displaying information. It can be collapsed to save space on the screen.\n\n### Guidelines:\n\n- Nesting two or more panels is not recommended.\n- Do not stack too many panels on one page.\n\n### Structure\nThe panel's header area consists of a title bar with a header text or custom header.\n\nThe header is clickable and can be used to toggle between the expanded and collapsed state. It includes an icon which rotates depending on the state.\n\nThe custom header can be set through the `header` slot and it may contain arbitraray content, such as: title, buttons or any other HTML elements.\n\nThe content area can contain an arbitrary set of controls.\n\n**Note:** The custom header is not clickable out of the box, but in this case the icon is interactive and allows to show/hide the content area.\n\n### Responsive Behavior\n\n- If the width of the panel is set to 100% (default), the panel and its children are\nresized responsively,\ndepending on its parent container.\n- If the panel has a fixed height, it will take up the space even if the panel is\ncollapsed.\n- When the panel is expandable (the `fixed` property is set to `false`),\nan arrow icon (pointing to the right) appears in front of the header.\n- When the animation is activated, expand/collapse uses a smooth animation to open or\nclose the content area.\n- When the panel expands/collapses, the arrow icon rotates 90 degrees\nclockwise/counter-clockwise.\n\n### Keyboard Handling\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [Panel UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Panel) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component. The content is visible only when the component is expanded.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the component header area.\n\n**Note:** When a header is provided, the `headerText` property is ignored.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onToggle": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<PanelDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is expanded/collapsed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "PanelAccessibleRole | \"Complementary\" | \"Form\" | \"Region\"",
-            "value": [
-              {
-                "value": "\"Complementary\"",
-                "description": "Represents the ARIA role \"complementary\".\nA section of the page, designed to be complementary to the main content at a similar level in the DOM hierarchy."
-              },
-              {
-                "value": "\"Form\"",
-                "description": "Represents the ARIA role \"Form\".\nA landmark region that contains a collection of items and objects that, as a whole, create a form."
-              },
-              {
-                "value": "\"Region\"",
-                "description": "Represents the ARIA role \"Region\".\nA section of a page, that is important enough to be included in a page summary or table of contents."
-              },
-              {
-                "value": "\"Complementary\""
-              },
-              {
-                "value": "\"Form\""
-              },
-              {
-                "value": "\"Region\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Sets the accessible ARIA role of the component.\nDepending on the usage, you can change the role from the default `Form`\nto `Region` or `Complementary`.",
-          "defaultValue": {
-            "value": "\"Form\""
-          }
-        },
-        "collapsed": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the component is collapsed and only the header is displayed.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "fixed": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is in a fixed state that is not\nexpandable/collapsible by user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "headerLevel": {
-          "type": {
-            "name": "enum",
-            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
-            "value": [
-              {
-                "value": "\"H1\"",
-                "description": "Renders `h1` tag."
-              },
-              {
-                "value": "\"H2\"",
-                "description": "Renders `h2` tag."
-              },
-              {
-                "value": "\"H3\"",
-                "description": "Renders `h3` tag."
-              },
-              {
-                "value": "\"H4\"",
-                "description": "Renders `h4` tag."
-              },
-              {
-                "value": "\"H5\"",
-                "description": "Renders `h5` tag."
-              },
-              {
-                "value": "\"H6\"",
-                "description": "Renders `h6` tag."
-              },
-              {
-                "value": "\"H1\""
-              },
-              {
-                "value": "\"H2\""
-              },
-              {
-                "value": "\"H3\""
-              },
-              {
-                "value": "\"H4\""
-              },
-              {
-                "value": "\"H5\""
-              },
-              {
-                "value": "\"H6\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the \"aria-level\" of component heading,\nset by the `headerText`.",
-          "defaultValue": {
-            "value": "\"H2\""
-          }
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "This property is used to set the header text of the component.\nThe text is visible in both expanded and collapsed states.\n\n**Note:** This property is overridden by the `header` slot."
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the transition between the expanded and the collapsed state of the component is animated. By default the animation is enabled.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "stickyHeader": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the Panel header is sticky or not.\nIf stickyHeader is set to true, then whenever you scroll the content or\nthe application, the header of the panel will be always visible and\na solid color will be used for its design.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<PanelDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "content",
-          "description": "Used to style the wrapper of the content."
-        },
-        {
-          "name": "header",
-          "description": "Used to style the wrapper of the header."
-        }
-      ]
-    },
-    "Popover": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Popover` component displays additional information for an object\nin a compact way and without leaving the page.\nThe Popover can contain various UI elements, such as fields, tables, images, and charts.\nIt can also include actions in the footer.\n\n### Structure\n\nThe popover has three main areas:\n\n- Header (optional)\n- Content\n- Footer (optional)\n\n**Note:** The `Popover` is closed when the user clicks\nor taps outside the popover\nor selects an action within the popover. You can prevent this with the\n`modal` property.\n\n\n\n__Note:__ This is a UI5 Web Component! [Popover UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Popover) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the Popup.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "footer": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the footer HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onBeforeClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<PopoverDomRef, PopupBeforeCloseEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "escPressed",
-                "type": "boolean",
-                "description": "Indicates that `ESC` key has triggered the event."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onBeforeOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<PopoverDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<PopoverDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<PopoverDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "PopupAccessibleRole | \"None\" | \"Dialog\" | \"AlertDialog\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "Represents no ARIA role."
-              },
-              {
-                "value": "\"Dialog\"",
-                "description": "Represents the ARIA role \"dialog\"."
-              },
-              {
-                "value": "\"AlertDialog\"",
-                "description": "Represents the ARIA role \"alertdialog\"."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Dialog\""
-              },
-              {
-                "value": "\"AlertDialog\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Dialog\""
-          }
-        },
-        "allowTargetOverlap": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines if there is no enough space, the component can be placed\nover the target.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text.\n\n**Note:** If `header` slot is provided, the `headerText` is ignored."
-        },
-        "hideArrow": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component arrow is hidden.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "horizontalAlign": {
-          "type": {
-            "name": "enum",
-            "raw": "PopoverHorizontalAlign | \"Center\" | \"Start\" | \"End\" | \"Stretch\"",
-            "value": [
-              {
-                "value": "\"Center\"",
-                "description": "Popover is centered."
-              },
-              {
-                "value": "\"Start\"",
-                "description": "Popover is aligned with the start of the target."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Popover is aligned with the end of the target."
-              },
-              {
-                "value": "\"Stretch\"",
-                "description": "Popover is stretched."
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Stretch\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the horizontal alignment of the component.",
-          "defaultValue": {
-            "value": "\"Center\""
-          }
-        },
-        "initialFocus": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the ID of the HTML Element, which will get the initial focus.\n\n**Note:** If an element with `autofocus` attribute is added inside the component,\n`initialFocus` won't take effect."
-        },
-        "modal": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should close when\nclicking/tapping outside the popover.\nIf enabled, it blocks any interaction with the background.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if the element is open\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "opener": {
-          "type": {
-            "name": "string | HTMLElement"
-          },
-          "required": false,
-          "description": "Defines the ID or DOM Reference of the element at which the popover is shown.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
-        },
-        "placement": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Start\" | \"End\" | PopoverPlacement | \"Top\" | \"Bottom\"",
-            "value": [
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Start\"",
-                "description": "Popover will be placed at the start of the reference element."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Popover will be placed at the end of the reference element."
-              },
-              {
-                "value": "\"Top\"",
-                "description": "Popover will be placed at the top of the reference element."
-              },
-              {
-                "value": "\"Bottom\"",
-                "description": "Popover will be placed at the bottom of the reference element."
-              },
-              {
-                "value": "\"Top\""
-              },
-              {
-                "value": "\"Bottom\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines on which side the component is placed at.",
-          "defaultValue": {
-            "value": "\"End\""
-          }
-        },
-        "preventFocusRestore": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "preventInitialFocus": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "resizable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is resizable.\n**Note:** This property is effective only on desktop devices.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "verticalAlign": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Center\" | \"Stretch\" | \"Top\" | \"Bottom\" | PopoverVerticalAlign",
-            "value": [
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Stretch\""
-              },
-              {
-                "value": "\"Top\""
-              },
-              {
-                "value": "\"Bottom\""
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Top\"",
-                "description": "Popover will be placed at the top of the reference control."
-              },
-              {
-                "value": "\"Bottom\"",
-                "description": "Popover will be placed at the bottom of the reference control."
-              },
-              {
-                "value": "\"Stretch\"",
-                "description": "Popover will be streched"
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the vertical alignment of the component.",
-          "defaultValue": {
-            "value": "\"Center\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<PopoverDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "applyFocus",
-          "description": "Focuses the element denoted by `initialFocus`, if provided, or the first focusable element otherwise.",
-          "params": [],
-          "returns": {
-            "type": "Promise<void>"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "content",
-          "description": "Used to style the content of the component"
-        },
-        {
-          "name": "footer",
-          "description": "Used to style the footer of the component"
-        },
-        {
-          "name": "header",
-          "description": "Used to style the header of the component"
-        }
-      ]
-    },
-    "ProductSwitch": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ProductSwitch` is an SAP Fiori specific web component that is used in `ShellBar`\nand allows the user to easily switch between products.\n\n### Keyboard Handling\nThe `ProductSwitch` provides advanced keyboard handling.\nWhen focused, the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Tab] - Move focus to the next interactive element after the `ProductSwitch`\n- [Up] or [Down] - Navigates up and down the items\n- [Left] or [Right] - Navigates left and right the items\n\n\n\n`import \"@ui5/webcomponents-fiori/dist/ProductSwitchItem.js\";` (for `ProductSwitchItem`)\n\n__Note:__ This is a UI5 Web Component! [ProductSwitch UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ProductSwitch) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the `ProductSwitch`.\n\n__Supported Node Type/s:__ `Array<IProductSwitchItem>`"
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ProductSwitchDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ProductSwitchItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ProductSwitchItem` web component represents the items displayed in the\n`ProductSwitch` web component.\n\n**Note:** `ProductSwitchItem` is not supported when used outside of `ProductSwitch`.\n\n### Keyboard Handling\nThe `ProductSwitch` provides advanced keyboard handling.\nWhen focused, the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Space] / [Enter] or [Return] - Trigger `ui5-click` event\n\n\n\n__Note:__ This is a UI5 Web Component! [ProductSwitchItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ProductSwitchItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "image": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines an image to be displayed instead of the standard icon.\n\n**Note:** The image slot takes precedence over the icon property.\n**Note:** We recommend using non-interactive ui5-avatar with size S, Square shape and Transparent colorScheme for best alignment.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"image\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ProductSwitchItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `ProductSwitchItem` is activated either with a\nclick/tap or by using the Enter or Space key.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed as a graphical element within the component.\n\nExample:\n\n`<ProductSwitchItem icon=\"palette\">`\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "subtitleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the subtitle of the component."
-        },
-        "target": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a target where the `targetSrc` content must be open.\n\nAvailable options are:\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `_search`\n\n**Note:** By default target will be open in the same frame as it was clicked."
-        },
-        "targetSrc": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the component target URI. Supports standard hyperlink behavior."
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the title of the component."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ProductSwitchItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ProgressIndicator": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Shows the progress of a process in a graphical way. To indicate the progress,\nthe inside of the component is filled with a color.\n\n### Responsive Behavior\nYou can change the size of the Progress Indicator by changing its `width` or `height` CSS properties.\n\n\n\n__Note:__ This is a UI5 Web Component! [ProgressIndicator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ProgressIndicator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.16.0](https://github.com/UI5/webcomponents/releases/tag/v1.16.0) of **@ui5/webcomponents**."
-        },
-        "displayValue": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Specifies the text value to be displayed in the bar.\n\n**Note:**\n\n- If there is no value provided or the value is empty, the default percentage value is shown.\n- If `hideValue` property is `true` both the `displayValue` and `value` property values are not shown."
-        },
-        "hideValue": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component value is shown.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Specifies the numerical value in percent for the length of the component.\n\n**Note:**\nIf a value greater than 100 is provided, the percentValue is set to 100. In other cases of invalid value, percentValue is set to its default of 0.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ProgressIndicatorDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "bar",
-          "description": "Used to style the main bar of the `ui5-progress-indicator`"
-        },
-        {
-          "name": "remaining-bar",
-          "description": "Used to style the remaining bar of the `ui5-progress-indicator`"
-        }
-      ]
-    },
-    "RadioButton": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `RadioButton` component enables users to select a single option from a set of options.\nWhen a `RadioButton` is selected by the user, the\n`change` event is fired.\nWhen a `RadioButton` that is within a group is selected, the one\nthat was previously selected gets automatically deselected. You can group radio buttons by using the `name` property.\n\n**Note:** If `RadioButton` is not part of a group, it can be selected once, but can not be deselected back.\n\n### Keyboard Handling\n\nOnce the `RadioButton` is on focus, it might be selected by pressing the Space and Enter keys.\n\nThe Arrow Down/Arrow Up and Arrow Left/Arrow Right keys can be used to change selection between next/previous radio buttons in one group,\nwhile TAB and SHIFT + TAB can be used to enter or leave the radio button group.\n\n**Note:** On entering radio button group, the focus goes to the currently selected radio button.\n\n\n\n__Note:__ This is a UI5 Web Component! [RadioButton UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/RadioButton) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<RadioButtonDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component checked state changes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.6.0](https://github.com/UI5/webcomponents/releases/tag/v1.6.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "checked": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is checked or not.\n\n**Note:** The property value can be changed with user interaction,\neither by clicking/tapping on the component,\nor by using the Space or Enter key.\n\n**Note:** Only enabled radio buttons can be checked.\nRead-only radio buttons are not selectable, and therefore are always unchecked.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\nRadio buttons with the same `name` will form a radio button group.\n\n**Note:** By this name the component will be identified upon submission in an HTML form.\n\n**Note:** The selection can be changed with `ARROW_UP/DOWN` and `ARROW_LEFT/RIGHT` keys between radio buttons in same group.\n\n**Note:** Only one radio button can be selected per group."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component isn't editable or selectable.\nHowever, because it's focusable, it still provides visual feedback upon user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the component."
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the form value of the component.\nWhen a form with a radio button group is submitted, the group's value\nwill be the value of the currently selected radio button."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | WrappingType | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines whether the component text wraps when there is not enough space.\n\n**Note:** for option \"Normal\" the text will wrap and the words will not be broken based on hyphenation.",
-          "defaultValue": {
-            "value": "\"Normal\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<RadioButtonDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "inner-ring",
-          "description": "Used to style the inner ring of the `ui5-radio-button`."
-        },
-        {
-          "name": "outer-ring",
-          "description": "Used to style the outer ring of the `ui5-radio-button`."
-        }
-      ]
-    },
-    "RangeSlider": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Represents a numerical interval and two handles (grips) to select a sub-range within it.\nThe purpose of the component to enable visual selection of sub-ranges within a given interval.\n\n### Structure\nThe most important properties of the Range Slider are:\n\n- min - The minimum value of the slider range.\n- max - The maximum value of the slider range.\n- value - The current value of the slider.\n- step - Determines the increments in which the slider will move.\n- showTooltip - Determines if a tooltip should be displayed above the handle.\n- showTickmarks - Displays a visual divider between the step values.\n- labelInterval - Labels some or all of the tickmarks with their values.\n\n#### Notes:\n\n- The right and left handle can be moved individually and their positions could therefore switch.\n- The entire range can be moved along the interval.\n\n### Usage\nThe most common use case is to select and move sub-ranges on a continuous numerical scale.\n\n### Responsive Behavior\nYou can move the currently selected range by clicking on it and dragging it along the interval.\n\n### Keyboard Handling\n\n- `Left or Down Arrow` - Moves a component's handle or the entire selection one step to the left;\n- `Right or Up Arrow` - Moves a component's handle or the entire selection one step to the right;\n- `Left or Down Arrow + Ctrl/Cmd` - Moves a component's handle to the left or the entire range with step equal to 1/10th of the entire range;\n- `Right or Up Arrow + Ctrl/Cmd` - Moves a component's handle to the right or the entire range with step equal to 1/10th of the entire range;\n- `Plus` - Same as `Right or Up Arrow`;\n- `Minus` - Same as `Left or Down Arrow`;\n- `Home` - Moves the entire selection or the selected handle to the beginning of the component's range;\n- `End` - Moves the entire selection or the selected handle to the end of the component's range;\n- `Page Up` - Same as `Right or Up Arrow + Ctrl/Cmd`;\n- `Page Down` - Same as `Left or Down Arrow + Ctrl/Cmd`;\n- `Escape` - Resets the `startValue` and `endValue` properties to the values prior the component focusing;\n\n\n\n__Note:__ This is a UI5 Web Component! [RangeSlider UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/RangeSlider) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<RangeSliderDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value changes and the user has finished interacting with the slider.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<RangeSliderDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value changes due to user interaction that is not yet finished - during mouse/touch dragging.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the slider is in disabled state.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "editableTooltip": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether input fields should be used as tooltips for the handles.\n\n**Note:** Setting this option to true will only work if showTooltip is set to true.\n**Note:** In order for the component to comply with the accessibility standard, it is recommended to set the editableTooltip property to true.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "endValue": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines end point of a selection - position of a second handle on the slider.",
-          "defaultValue": {
-            "value": "100"
-          }
-        },
-        "labelInterval": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Displays a label with a value on every N-th step.\n\n**Note:** The step and tickmarks properties must be enabled.\nExample - if the step value is set to 2 and the label interval is also specified to 2 - then every second\ntickmark will be labelled, which means every 4th value number.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "max": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the maximum value of the slider.",
-          "defaultValue": {
-            "value": "100"
-          }
-        },
-        "min": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the minimum value of the slider.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
-        },
-        "showTickmarks": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Enables tickmarks visualization for each step.\n\n**Note:** The step must be a positive number.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showTooltip": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Enables handle tooltip displaying the current value.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "startValue": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines start point of a selection - position of a first handle on the slider.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "step": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the size of the slider's selection intervals (e.g. min = 0, max = 10, step = 5 would result in possible selection of the values 0, 5, 10).\n\n**Note:** If set to 0 the slider handle movement is disabled. When negative number or value other than a number, the component fallbacks to its default value.",
-          "defaultValue": {
-            "value": "1"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<RangeSliderDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "handle",
-          "description": "Used to style the handles of the `ui5-range-slider`."
-        },
-        {
-          "name": "progress-bar",
-          "description": "Used to style the progress bar, which shows the progress of the `ui5-range-slider`."
-        },
-        {
-          "name": "progress-container",
-          "description": "Used to style the progress container, the horizontal bar that visually represents the range between the minimum and maximum values, of the `ui5-range-slider`."
-        }
-      ]
-    },
-    "RatingIndicator": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The Rating Indicator is used to display a specific number of icons that are used to rate an item.\nAdditionally, it is also used to display the average and overall ratings.\n\n### Usage\nThe recommended number of icons is between 5 and 7.\n\n### Responsive Behavior\nYou can change the size of the Rating Indicator by changing its `font-size` CSS property.\n\nExample: `<RatingIndicator style=\"font-size: 3rem;\"></RatingIndicator>`\n\n### Keyboard Handling\nWhen the `RatingIndicator` is focused, the user can change the rating\nwith the following keyboard shortcuts:\n\n- [RIGHT/UP] - Increases the value of the rating by one step. If the highest value is reached, does nothing\n- [LEFT/DOWN] - Decreases the value of the rating by one step. If the lowest value is reached, does nothing.\n- [Home] - Sets the lowest value.\n- [End] - Sets the highest value.\n- [SPACE/ENTER/RETURN] - Increases the value of the rating by one step. If the highest value is reached, sets the rating to the lowest value.\n- Any number - Changes value to the corresponding number. If typed number is larger than the number of values, sets the highest value.\n\n\n\n__Note:__ This is a UI5 Web Component! [RatingIndicator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/RatingIndicator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<RatingIndicatorDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "The event is fired when the value changes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "max": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The number of displayed rating symbols.",
-          "defaultValue": {
-            "value": "5"
-          }
-        },
-        "ratedIcon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed for the selected (filled) rating symbol.\n\n**Note:** Available since [v2.20](https://github.com/UI5/webcomponents/releases/tag/v2.20) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"favorite\""
-          }
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "size": {
-          "type": {
-            "name": "enum",
-            "raw": "RatingIndicatorSize | \"S\" | \"M\" | \"L\"",
-            "value": [
-              {
-                "value": "\"S\"",
-                "description": "Small size for compact layouts."
-              },
-              {
-                "value": "\"M\"",
-                "description": "Medium size, used as the default option.\nOffers a balanced appearance for most scenarios."
-              },
-              {
-                "value": "\"L\"",
-                "description": "Large size for prominent or spacious layouts."
-              },
-              {
-                "value": "\"S\""
-              },
-              {
-                "value": "\"M\""
-              },
-              {
-                "value": "\"L\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the size of the component.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"M\""
-          }
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents**."
-        },
-        "unratedIcon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed for the unselected (empty) rating symbol.\n\n**Note:** Available since [v2.20](https://github.com/UI5/webcomponents/releases/tag/v2.20) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"unfavorite\""
-          }
-        },
-        "value": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The indicated value of the rating.\n\n**Note:** If you set a number which is not round, it would be shown as follows:\n\n- 1.0 - 1.2 -> 1\n- 1.3 - 1.7 -> 1.5\n- 1.8 - 1.9 -> 2",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<RatingIndicatorDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ResponsivePopover": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ResponsivePopover` acts as a Popover on desktop and tablet, while on phone it acts as a Dialog.\nThe component improves tremendously the user experience on mobile.\n\n### Usage\nUse it when you want to make sure that all the content is visible on any device.\n\n\n\n__Note:__ This is a UI5 Web Component! [ResponsivePopover UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ResponsivePopover) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the Popup.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "footer": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the footer HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header HTML Element.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onBeforeClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, PopupBeforeCloseEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is closed. This event can be cancelled, which will prevent the popup from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "escPressed",
-                "type": "boolean",
-                "description": "Indicates that `ESC` key has triggered the event."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onBeforeOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is opened. This event can be cancelled, which will prevent the popup from opening.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ResponsivePopoverDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the component.\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "PopupAccessibleRole | \"None\" | \"Dialog\" | \"AlertDialog\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "Represents no ARIA role."
-              },
-              {
-                "value": "\"Dialog\"",
-                "description": "Represents the ARIA role \"dialog\"."
-              },
-              {
-                "value": "\"AlertDialog\"",
-                "description": "Represents the ARIA role \"alertdialog\"."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Dialog\""
-              },
-              {
-                "value": "\"AlertDialog\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Allows setting a custom role.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Dialog\""
-          }
-        },
-        "allowTargetOverlap": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines if there is no enough space, the component can be placed\nover the target.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text.\n\n**Note:** If `header` slot is provided, the `headerText` is ignored."
-        },
-        "hideArrow": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component arrow is hidden.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "horizontalAlign": {
-          "type": {
-            "name": "enum",
-            "raw": "PopoverHorizontalAlign | \"Center\" | \"Start\" | \"End\" | \"Stretch\"",
-            "value": [
-              {
-                "value": "\"Center\"",
-                "description": "Popover is centered."
-              },
-              {
-                "value": "\"Start\"",
-                "description": "Popover is aligned with the start of the target."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Popover is aligned with the end of the target."
-              },
-              {
-                "value": "\"Stretch\"",
-                "description": "Popover is stretched."
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Stretch\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the horizontal alignment of the component.",
-          "defaultValue": {
-            "value": "\"Center\""
-          }
-        },
-        "initialFocus": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the ID of the HTML Element, which will get the initial focus.\n\n**Note:** If an element with `autofocus` attribute is added inside the component,\n`initialFocus` won't take effect."
-        },
-        "modal": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should close when\nclicking/tapping outside the popover.\nIf enabled, it blocks any interaction with the background.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if the element is open\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "opener": {
-          "type": {
-            "name": "string | HTMLElement"
-          },
-          "required": false,
-          "description": "Defines the ID or DOM Reference of the element at which the popover is shown.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
-        },
-        "placement": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Start\" | \"End\" | PopoverPlacement | \"Top\" | \"Bottom\"",
-            "value": [
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Start\"",
-                "description": "Popover will be placed at the start of the reference element."
-              },
-              {
-                "value": "\"End\"",
-                "description": "Popover will be placed at the end of the reference element."
-              },
-              {
-                "value": "\"Top\"",
-                "description": "Popover will be placed at the top of the reference element."
-              },
-              {
-                "value": "\"Bottom\"",
-                "description": "Popover will be placed at the bottom of the reference element."
-              },
-              {
-                "value": "\"Top\""
-              },
-              {
-                "value": "\"Bottom\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines on which side the component is placed at.",
-          "defaultValue": {
-            "value": "\"End\""
-          }
-        },
-        "preventFocusRestore": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the focus should be returned to the previously focused element,\nwhen the popup closes.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "preventInitialFocus": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether initial focus should be prevented.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "resizable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is resizable.\n**Note:** This property is effective only on desktop devices.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "verticalAlign": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Center\" | \"Stretch\" | \"Top\" | \"Bottom\" | PopoverVerticalAlign",
-            "value": [
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Stretch\""
-              },
-              {
-                "value": "\"Top\""
-              },
-              {
-                "value": "\"Bottom\""
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Top\"",
-                "description": "Popover will be placed at the top of the reference control."
-              },
-              {
-                "value": "\"Bottom\"",
-                "description": "Popover will be placed at the bottom of the reference control."
-              },
-              {
-                "value": "\"Stretch\"",
-                "description": "Popover will be streched"
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the vertical alignment of the component.",
-          "defaultValue": {
-            "value": "\"Center\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ResponsivePopoverDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "applyFocus",
-          "description": "Focuses the element denoted by `initialFocus`, if provided, or the first focusable element otherwise.",
-          "params": [],
-          "returns": {
-            "type": "Promise<void>"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "content",
-          "description": "Used to style the content of the component"
-        },
-        {
-          "name": "footer",
-          "description": "Used to style the footer of the component"
-        },
-        {
-          "name": "header",
-          "description": "Used to style the header of the component"
-        }
-      ]
-    },
-    "Search": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A `Search` is an input with suggestions, used for user search.\n\nThe `Search` consists of several elements parts:\n- Scope - displays a select in the beggining of the component, used for filtering results by their scope.\n- Input field - for user input value\n- Clear button - gives the possibility for deleting the entered value\n- Search button - a primary button for performing search, when the user has entered a search term\n- Suggestions - a list with available search suggestions\n\n\n\n__Note:__ This is a UI5 Web Component! [Search UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/Search) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "action": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the popup footer action button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"action\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<Button>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the Search suggestion items.\n\n__Supported Node Type/s:__ `Array<SearchItem | SearchItemGroup>`"
-        },
-        "filterButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the filter button slot, used to display an additional filtering button.\nThis slot is intended for passing a `ui5-button` with a filter icon to provide extended filtering options.\n\n**Note:** Scope button and Filter button are mutually exclusive.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"filterButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<Button>`"
-        },
-        "illustration": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the illustrated message to be shown in the popup.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"illustration\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IllustratedMessage>`"
-        },
-        "messageArea": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the illustrated message to be shown in the popup.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"messageArea\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<SearchMessageArea>`"
-        },
-        "scopes": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the component scope options.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"scopes\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ISearchScope>`"
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SearchDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the popup is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SearchDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when typing in input or clear icon is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SearchDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the popup is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onScopeChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SearchDomRef, SearchFieldScopeSelectionChangeDetails>) => void"
-          },
-          "required": false,
-          "description": "Fired when the scope has changed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "scope",
-                "type": "HTMLElement",
-                "description": "The newly selected scope"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSearch": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SearchDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user has triggered search with Enter key or Search Button press.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA description of the field."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "fieldLoading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether a loading indicator should be shown in the input field.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether a loading indicator should be shown in the popup.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "noTypeahead": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the value will be autcompleted to match an item.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the items picker is open.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
-        },
-        "scopeValue": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component:\n\nApplications are responsible for setting the correct scope value.\n\n**Note:** If the given value does not match any existing scopes,\nno scope will be selected and the SearchField scope component will be displayed as empty.\n\n**Note:** Available since [v2.18.0](https://github.com/UI5/webcomponents/releases/tag/v2.18.0) of **@ui5/webcomponents-fiori**."
-        },
-        "showClearIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the clear icon of the search will be shown.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SearchDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SearchItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A `SearchItem` is a list item, used for displaying search suggestions\n\n\n\n__Note:__ This is a UI5 Web Component! [SearchItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SearchItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "actions": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the actionable elements.\nThis slot allows placing additional interactive elements (such as buttons, icons, or tags)\nnext to the delete button, providing flexible customization for various user actions.\n\n**Note:** While the slot is flexible, for consistency with design guidelines,\nit's recommended to use `ui5-button` with `Transparent` design or `ui5-icon` elements.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"actions\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "image": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "**Note:** While the slot allows the option of setting a custom avatar, to comply with the\ndesign guidelines, use the `ui5-avatar` with size - XS.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"image\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onDelete": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SearchItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when delete button is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "deletable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the search item is deletable.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "description": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the description that appears right under the item text, if available.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents-fiori**."
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon name of the search item.\n**Note:** If provided, the image slot will be ignored."
-        },
-        "scopeName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the scope of the search item"
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the search item is selected.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the heading text of the search item."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SearchItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SearchItemGroup": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `SearchItemGroup` is type of suggestion item,\nthat can be used to split the `SearchItem` suggestions into groups.\n\n__Note:__ This is a UI5 Web Component! [SearchItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SearchItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the <code>ui5-li-group</code>.\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
-        },
-        "onMove": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SearchItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMoveOver": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SearchItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "headerAccessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the header."
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text of the <code>ui5-li-group</code>."
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "WrappingType | \"None\" | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ui5-expandable-text` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SearchItemGroupDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "header",
-          "description": "Used to style the header item of the group"
-        },
-        {
-          "name": "title",
-          "description": "Used to style the title of the group header"
-        }
-      ]
-    },
-    "SearchItemShowMore": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A `SearchItemShowMore` is a special type of ui5-li that acts as a button to progressively reveal additional (overflow) items within a group.\n\n\n\n__Note:__ This is a UI5 Web Component! [SearchItemShowMore UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SearchItemShowMore) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SearchItemShowMoreDomRef, ShowMoreItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is activated, either with a mouse/tap\nor by pressing the Enter or Space keys.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "fromKeyboard",
-                "type": "boolean",
-                "description": "Indicates whether the event was fired\ndue to keyboard interaction (Enter or Space) rather than mouse/tap."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "itemsToShowCount": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Specifies the number of additional items available to show.\nIf no value is defined, the control shows \"Show more\" (without any counter).\nIf a number is provided, it displays \"Show more (N)\", where N is that number."
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the show more item is selected.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SearchItemShowMoreDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SearchMessageArea": {
-      "package": "@ui5/webcomponents-react",
-      "description": "`import \"@ui5/webcomponents-fiori/dist/SearchMessageArea.js\";`\n\n__Note:__ This is a UI5 Web Component! [SearchMessageArea UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SearchMessageArea) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "description": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the description text to be displayed."
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text to be displayed."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SearchMessageAreaDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SearchScope": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `SearchScope` represents the options for the scope in `Search`.\n\n__Note:__ This is a UI5 Web Component! [SearchScope UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SearchScope) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the component."
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the `SearchScope`.\nUsed for selection in Search scopes."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SearchScopeDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SegmentedButton": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `SegmentedButton` shows a group of items. When the user clicks or taps\none of the items, it stays in a pressed state. It automatically resizes the items\nto fit proportionally within the component. When no width is set, the component uses the available width.\n\n\n\n\n__Note:__ This is a UI5 Web Component! [SegmentedButton UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SegmentedButton) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of `SegmentedButton`.\n\n**Note:** Multiple items are allowed.\n\n**Note:** Use the `SegmentedButtonItem` for the intended design.\n\n__Supported Node Type/s:__ `Array<ISegmentedButtonItem>`"
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SegmentedButtonDomRef, SegmentedButtonSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the selected item changes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "selectedItems",
-                "type": "Array<ISegmentedButtonItem>",
-                "description": "an array of selected items. Since: 1.14.0"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the HTML Elements that describe the component.\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.0.3](https://github.com/UI5/webcomponents/releases/tag/v1.0.3) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the HTML Elements that label the component.\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
-        },
-        "itemsFitContent": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the segmented button items should be sized to fit their content.\n\nIf set to `true`, each item will be sized to fit its content, with any extra space distributed after the last item.\nIf set to `false` (the default), all items will be equally sized to fill the available space.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selectionMode": {
-          "type": {
-            "name": "enum",
-            "raw": "SegmentedButtonSelectionMode | \"Single\" | \"Multiple\"",
-            "value": [
-              {
-                "value": "\"Single\"",
-                "description": "There is always one selected. Selecting one deselects the previous one."
-              },
-              {
-                "value": "\"Multiple\"",
-                "description": "Multiple items can be selected at a time. All items can be deselected."
-              },
-              {
-                "value": "\"Single\""
-              },
-              {
-                "value": "\"Multiple\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component selection mode.\n\n**Note:** Available since [v1.14.0](https://github.com/UI5/webcomponents/releases/tag/v1.14.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Single\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SegmentedButtonDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SegmentedButtonItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Users can use the `SegmentedButtonItem` as part of a `SegmentedButton`.\n\nClicking or tapping on a `SegmentedButtonItem` changes its state to `selected`.\nThe item returns to its initial state when the user clicks or taps on it again.\nBy applying additional custom CSS-styling classes, apps can give a different style to any\n`SegmentedButtonItem`.\n\n\n\n__Note:__ This is a UI5 Web Component! [SegmentedButtonItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SegmentedButtonItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the HTML Elements that describe the component.\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\nA disabled component can't be selected or\nfocused, and it is not in the tab chain.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon, displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is displayed as selected.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\n**Note:** A tooltip attribute should be provided for icon-only buttons, in order to represent their exact meaning/function.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SegmentedButtonItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Select": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Select` component is used to create a drop-down list.\n\n### Usage\n\nThere are two main usages of the `ui5-select>`.\n\n- With Option (`Option`) web component:\n\nThe available options of the Select are defined by using the Option component.\nThe Option comes with predefined design and layout, including `icon`, `text` and `additional-text`.\n\n- With OptionCustom (`OptionCustom`) web component.\n\nOptions with custom content are defined by using the OptionCustom component.\nThe OptionCustom component comes with no predefined layout and it expects consumers to define it.\n\n### Selection\n\nThe options can be selected via user interaction (click or with the use of the Space and Enter keys)\nand programmatically - the Select component supports two distinct selection APIs, though mixing them is not supported:\n- The \"value\" property of the Select component\n- The \"selected\" property on individual options\n\n**Note:** If the \"value\" property is set but does not match any option,\nno option will be selected and the Select component will be displayed as empty.\n\n**Note:** when both \"value\" and \"selected\" are both used (although discouraged),\nthe \"value\" property will take precedence.\n\n### Keyboard Handling\n\nThe `Select` provides advanced keyboard handling.\n\n- [F4] / [Alt] + [Up] / [Alt] + [Down] / [Space] or [Enter] - Opens/closes the drop-down.\n- [Up] or [Down] - If the drop-down is closed - changes selection to the next or the previous option. If the drop-down is opened - moves focus to the next or the previous option.\n- [Space], [Enter] - If the drop-down is opened - selects the focused option.\n- [Escape] - Closes the drop-down without changing the selection.\n- [Home] - Navigates to first option\n- [End] - Navigates to the last option\n\n\n\n`import \"@ui5/webcomponents/dist/Option\";`\n`import \"@ui5/webcomponents/dist/OptionCustom\";`\n\n__Note:__ This is a UI5 Web Component! [Select UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Select) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the component options.\n\n**Note:** Only one selected option is allowed.\nIf more than one option is defined as selected, the last one would be considered as the selected one.\n\n**Note:** Use the `Option` component to define the desired options.\n\n__Supported Node Type/s:__ `Array<IOption>`"
-        },
-        "label": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the HTML element that will be displayed in the component input part,\nrepresenting the selected option.\n\n**Note:** If not specified and `OptionCustom` is used,\neither the option's `display-text` or its textContent will be displayed.\n\n**Note:** If not specified and `Option` is used,\nthe option's textContent will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"label\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.17.0](https://github.com/UI5/webcomponents/releases/tag/v1.17.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n**Note:** If the component has `suggestionItems`,\nthe `valueStateMessage` would be displayed as part of the same popover, if used on desktop, or dialog - on phone.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SelectDomRef, SelectChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the selected option changes.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "selectedOption",
-                "type": "IOption",
-                "description": "the selected option."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SelectDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component's dropdown menu closes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onLiveChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SelectDomRef, SelectLiveChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user navigates through the options, but the selection is not finalized,\nor when pressing the ESC key to revert the current selection.\n\n**Note:** Available since [v1.17.0](https://github.com/UI5/webcomponents/releases/tag/v1.17.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "selectedOption",
-                "type": "IOption",
-                "description": "the selected option."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SelectDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component's dropdown menu opens.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the select.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the select."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.\n\n**Note:** Available since [v1.21.0](https://github.com/UI5/webcomponents/releases/tag/v1.21.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "textSeparator": {
-          "type": {
-            "name": "enum",
-            "raw": "SelectTextSeparator | \"Bullet\" | \"Dash\" | \"VerticalLine\"",
-            "value": [
-              {
-                "value": "\"Bullet\"",
-                "description": "Will show bullet(·) as separator on two columns layout when Select is in read-only mode."
-              },
-              {
-                "value": "\"Dash\"",
-                "description": "Will show N-dash(–) as separator on two columns layout when Select is in read-only mode."
-              },
-              {
-                "value": "\"VerticalLine\"",
-                "description": "Will show vertical line(|) as separator on two columns layout when Select is in read-only mode."
-              },
-              {
-                "value": "\"Bullet\""
-              },
-              {
-                "value": "\"Dash\""
-              },
-              {
-                "value": "\"VerticalLine\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the separator type for the two columns layout when Select is in read-only mode.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Dash\""
-          }
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the select.\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**."
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component:\n\n- when get - returns the value of the component or the value/text content of the selected option.\n- when set - selects the option with matching `value` property or text content.\n\n**Note:** Use either the Select's value or the Options' selected property.\nMixed usage could result in unexpected behavior.\n\n**Note:** If the given value does not match any existing option,\nno option will be selected and the Select component will be displayed as empty.\n\n**Note:** Available since [v1.20.0](https://github.com/UI5/webcomponents/releases/tag/v1.20.0) of **@ui5/webcomponents**."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SelectDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "popover",
-          "description": "Used to style the popover element"
-        }
-      ]
-    },
-    "ShellBar": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ShellBar` is meant to serve as an application header\nand includes numerous built-in features, such as: logo, profile image/icon, title, search field, notifications and so on.\n\n### Stable DOM Refs\n\nYou can use the following stable DOM refs for the `ShellBar`:\n\n- logo\n- notifications\n- overflow\n- profile\n- product-switch\n\n### Keyboard Handling\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n__Note:__ This is a UI5 Web Component! [ShellBar UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ShellBar) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "assistant": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the assistant slot.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"assistant\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "branding": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the branding slot.\nThe `ShellBarBranding` component is intended to be placed inside this slot.\nContent placed here takes precedence over the `primaryTitle` property and the `logo` content slot.\n\n**Note:** The `branding` slot is in an experimental state and is a subject to change.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"branding\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<ShellBarBranding>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the `ShellBar` additional items.\n\n**Note:**\nYou can use the `<ShellBarItem></ShellBarItem>`.\n\n__Supported Node Type/s:__ `Array<ShellBarItem>`"
-        },
-        "content": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Define the items displayed in the content area.\n\nUse the `data-hide-order` attribute with numeric value to specify the order of the items to be hidden when the space is not enough.\nLower values will be hidden first.\n\n**Note:** The `content` slot is in an experimental state and is a subject to change.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"content\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "logo": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the logo of the `ShellBar`.\nFor example, you can use `ui5-avatar` or `img` elements as logo.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"logo\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "menuItems": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the items displayed in menu after a click on a start button.\n\n**Note:** You can use the  `<ui5-li></ui5-li>` and its ancestors.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"menuItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
-        },
-        "profile": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "You can pass `ui5-avatar` to set the profile image/icon.\nIf no profile slot is set - profile will be excluded from actions.\n\n**Note:** We recommend not using the `size` attribute of `ui5-avatar` because\nit should have specific size by design in the context of `ShellBar` profile.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"profile\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "searchField": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the `ui5-input`, that will be used as a search field.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"searchField\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IShellBarSearchField>`"
-        },
-        "startButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines a `ui5-button` in the bar that will be placed in the beginning.\nWe encourage this slot to be used for a menu button.\nIt gets overstyled to match ShellBar's styling.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"startButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "onContentItemVisibilityChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarContentItemVisibilityChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired, when an item from the content slot is hidden or shown.\n**Note:** The `content-item-visibility-change` event is in an experimental state and is a subject to change.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "array",
-                "type": "Array<HTMLElement>",
-                "description": "of all the items that are hidden"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onLogoClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarLogoClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired, when the logo is activated.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "targetRef",
-                "type": "HTMLElement",
-                "description": "dom ref of the activated element"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMenuItemClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarMenuItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired, when a menu item is activated\n\n**Note:** You can prevent closing of overflow popover by calling `event.preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "DOM ref of the activated list item"
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onNotificationsClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarNotificationsClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired, when the notification icon is activated.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "targetRef",
-                "type": "HTMLElement",
-                "description": "dom ref of the activated element"
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onProductSwitchClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarProductSwitchClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired, when the product switch icon is activated.\n\n**Note:** You can prevent closing of overflow popover by calling `event.preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "targetRef",
-                "type": "HTMLElement",
-                "description": "dom ref of the activated element"
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onProfileClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarProfileClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired, when the profile slot is present.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "targetRef",
-                "type": "HTMLElement",
-                "description": "dom ref of the activated element"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSearchButtonClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarSearchButtonEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired, when the search button is activated.\n\n**Note:** You can prevent expanding/collapsing of the search field by calling `event.preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "searchFieldVisible",
-                "type": "Boolean",
-                "description": "whether the search field is visible"
-              },
-              {
-                "name": "targetRef",
-                "type": "HTMLElement",
-                "description": "dom ref of the activated element"
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onSearchFieldClear": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarSearchFieldClearEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired, when the search cancel button is activated.\n\n**Note:** You can prevent the default behavior (clearing the search field value) by calling `event.preventDefault()`. The search will still be closed.\n**Note:** The `search-field-clear` event is in an experimental state and is a subject to change.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "targetRef",
-                "type": "HTMLElement",
-                "description": "dom ref of the cancel button element"
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onSearchFieldToggle": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarDomRef, ShellBarSearchFieldToggleEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired, when the search field is expanded or collapsed.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "expanded",
-                "type": "Boolean",
-                "description": "whether the search field is expanded"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ShellBarAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines additional accessibility attributes on different areas of the component.\n\nThe accessibilityAttributes object has the following fields,\nwhere each field is an object supporting one or more accessibility attributes:\n\n- **logo** - `logo.role` and `logo.name`.\n- **notifications** - `notifications.expanded` and `notifications.hasPopup`.\n- **profile** - `profile.expanded`, `profile.hasPopup` and `profile.name`.\n- **product** - `product.expanded` and `product.hasPopup`.\n- **search** - `search.hasPopup`.\n- **overflow** - `overflow.expanded` and `overflow.hasPopup`.\n- **branding** - `branding.name`.\n\nThe accessibility attributes support the following values:\n\n- **role**: Defines the accessible ARIA role of the logo area.\nAccepts the following string values: `button` or `link`.\n\n- **expanded**: Indicates whether the button, or another grouping element it controls,\nis currently expanded or collapsed.\nAccepts the following string values: `true` or `false`.\n\n- **hasPopup**: Indicates the availability and type of interactive popup element,\nsuch as menu or dialog, that can be triggered by the button.\n\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n- **name**: Defines the accessible ARIA name of the area.\nAccepts any string.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "disableSearchCollapse": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Disables the automatic search field expansion/collapse when the available space is not enough.\n\n**Note:** The `disableSearchCollapse` property is in an experimental state and is a subject to change.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideSearchButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the visibility state of the search button.\n\n**Note:** The `hideSearchButton` property is in an experimental state and is a subject to change.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "notificationsCount": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `notificationsCount`,\ndisplayed in the notification icon top-right corner."
-        },
-        "primaryTitle": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `primaryTitle`.\n\n**Note:** The `primaryTitle` would be hidden on S screen size (less than approx. 700px)."
-        },
-        "secondaryTitle": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `secondaryTitle`.\n\n**Note:** The `secondaryTitle` would be hidden on S and M screen sizes (less than approx. 1300px)."
-        },
-        "showNotifications": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines, if the notification icon would be displayed.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showProductSwitch": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines, if the product switch icon would be displayed.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showSearchField": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines, if the Search Field would be displayed when there is a valid `searchField` slot.\n\n**Note:** By default the Search Field is not displayed.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ShellBarDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "closeOverflow",
-          "description": "Closes the overflow popover.",
-          "params": [],
-          "returns": {
-            "type": "void"
-          }
-        },
-        {
-          "name": "getSearchButtonDomRef",
-          "description": "Returns the search button DOM reference.",
-          "params": [],
-          "returns": {
-            "type": "Promise<HTMLElement | null>"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "root",
-          "description": "Used to style the outermost wrapper of the `ui5-shellbar`"
-        }
-      ]
-    },
-    "ShellBarBranding": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ShellBarBranding` component is intended to be placed inside the branding slot of the\n`ShellBar` component. Its content has higher priority than the `primaryTitle` property\nand the `logo` slot of `ShellBar`.\n\n__Note:__ This is a UI5 Web Component! [ShellBarBranding UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ShellBarBranding) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the title for the ui5-shellbar-branding component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "logo": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the logo of the `ShellBar`.\nFor example, you can use `ui5-avatar` or `img` elements as logo.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"logo\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarBrandingDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired, when the logo is activated.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text alternative of the component.\nIf not provided a default text alternative will be set, if present."
-        },
-        "href": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the component href.\n\n**Note:** Standard hyperlink behavior is supported."
-        },
-        "target": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the component target.\n\n**Notes:**\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `_search`\n\n**This property must only be used when the `href` property is set.**"
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ShellBarBrandingDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ShellBarItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ShellBarItem` represents a custom item for `ShellBar`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ShellBarItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ShellBarItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarItemDomRef, ShellBarItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the item is clicked.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "targetRef",
-                "type": "HTMLElement",
-                "description": "DOM ref of the clicked element"
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ShellBarItemAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines additional accessibility attributes on Shellbar Items.\n\nThe accessibility attributes support the following values:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls,\nis currently expanded or collapsed.\nAccepts the following string values: `true` or `false`.\n\n- **hasPopup**: Indicates the availability and type of interactive popup element,\nsuch as menu or dialog, that can be triggered by the button.\n\n- **controls**: Identifies the element (or elements) whose contents\nor presence are controlled by the component.\nAccepts a lowercase string value, referencing the ID of the element it controls.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "count": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the count displayed in badge."
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the item's icon."
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the item text.\n\n**Note:** The text is only displayed inside the overflow popover list view."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ShellBarItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ShellBarSearch": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Search field for the ShellBar component.\n\n__Note:__ This is a UI5 Web Component! [ShellBarSearch UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ShellBarSearch) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "action": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the popup footer action button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"action\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<Button>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the Search suggestion items.\n\n__Supported Node Type/s:__ `Array<SearchItem | SearchItemGroup>`"
-        },
-        "filterButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the filter button slot, used to display an additional filtering button.\nThis slot is intended for passing a `ui5-button` with a filter icon to provide extended filtering options.\n\n**Note:** Scope button and Filter button are mutually exclusive.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"filterButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.11.0](https://github.com/UI5/webcomponents/releases/tag/v2.11.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<Button>`"
-        },
-        "illustration": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the illustrated message to be shown in the popup.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"illustration\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IllustratedMessage>`"
-        },
-        "messageArea": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the illustrated message to be shown in the popup.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"messageArea\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<SearchMessageArea>`"
-        },
-        "scopes": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the component scope options.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"scopes\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ISearchScope>`"
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarSearchDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the popup is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarSearchDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when typing in input or clear icon is pressed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarSearchDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the popup is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onScopeChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarSearchDomRef, SearchFieldScopeSelectionChangeDetails>) => void"
-          },
-          "required": false,
-          "description": "Fired when the scope has changed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "scope",
-                "type": "HTMLElement",
-                "description": "The newly selected scope"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSearch": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ShellBarSearchDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user has triggered search with Enter key or Search Button press.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA description of the field."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "autoOpen": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the suggestions popover should be opened on focus.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "fieldLoading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether a loading indicator should be shown in the input field.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether a loading indicator should be shown in the popup.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "noTypeahead": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the value will be autcompleted to match an item.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the items picker is open.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
-        },
-        "scopeValue": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component:\n\nApplications are responsible for setting the correct scope value.\n\n**Note:** If the given value does not match any existing scopes,\nno scope will be selected and the SearchField scope component will be displayed as empty.\n\n**Note:** Available since [v2.18.0](https://github.com/UI5/webcomponents/releases/tag/v2.18.0) of **@ui5/webcomponents-fiori**."
-        },
-        "showClearIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the clear icon of the search will be shown.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ShellBarSearchDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ShellBarSpacer": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ShellBarSpacer` is an element, used for visual separation between the two content parts of the `ShellBar`.\n**Note:** The `ShellBarSpacer` component is in an experimental state and is a subject to change.\n\n__Note:__ This is a UI5 Web Component! [ShellBarSpacer UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ShellBarSpacer) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ShellBarSpacerDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SideNavigation": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `SideNavigation` is used as a standard menu in applications.\nIt consists of three containers: header (top-aligned), main navigation section (top-aligned) and the secondary section (bottom-aligned).\n\n - The header is meant for displaying user related information - profile data, avatar, etc.\n - The main navigation section is related to the user's current work context.\n - The secondary section is mostly used to link additional information that may be of interest (legal information, developer communities, external help, contact information and so on).\n\n### Usage\n\nUse the available `SideNavigationGroup`, `SideNavigationItem`\nand `SideNavigationSubItem` components to build your menu.\nThe items can consist of text only or an icon with text. The use or non-use of icons must be consistent for all items on one level.\nYou must not combine entries with and without icons on the same level. We strongly recommend that you do not use icons on the second level.\n\nThe `SideNavigation` component is designed to be used within a `NavigationLayout` component to ensure an optimal user experience.\n\nUsing it standalone may not match the intended design and functionality.\nFor example, the side navigation may not exhibit the correct behavior on smaller screens.\nAdditionally, the padding of the `ShellBar` will not match the padding of the side navigation.\n\n### Keyboard Handling\n\n### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n\n`import \"@ui5/webcomponents-fiori/dist/SideNavigationGroup.js\";` (for `SideNavigationGroup`)\n\n`import \"@ui5/webcomponents-fiori/dist/SideNavigationItem.js\";` (for `SideNavigationItem`)\n\n`import \"@ui5/webcomponents-fiori/dist/SideNavigationSubItem.js\";` (for `SideNavigationSubItem`)\n\n__Note:__ This is a UI5 Web Component! [SideNavigation UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SideNavigation) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the main items of the component.\n\n__Supported Node Type/s:__ `Array<SideNavigationItemBase>`"
-        },
-        "fixedItems": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the fixed items at the bottom of the component.\n\n**Note:** In order to achieve the best user experience, it is recommended that you keep the fixed items \"flat\" (do not pass sub-items)\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"fixedItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<SideNavigationItemBase>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header of the `SideNavigation`.\n\n**Note:** The header is displayed when the component is expanded - the property `collapsed` is false;\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onItemClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SideNavigationDomRef, SideNavigationItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when an item is clicked.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "SideNavigationSelectableItemBase",
-                "description": "The clicked item."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SideNavigationDomRef, SideNavigationSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the selection has changed via user interaction.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "SideNavigationSelectableItemBase",
-                "description": "The selected item."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents-fiori**."
-        },
-        "collapsed": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the `SideNavigation` is expanded or collapsed.\n\n**Note:** On small screens (screen width of 599px or less) the collapsed mode is not supported, and in\nexpanded mode the side navigation will take the whole width of the screen.\nThe `SideNavigation` component is intended to be used within a `NavigationLayout`\ncomponent to ensure proper responsive behavior. If you choose not to use the\n`NavigationLayout`, you will need to implement the appropriate responsive patterns yourself,\nparticularly for smaller screens where the collapsed mode should not be used.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SideNavigationDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SideNavigationGroup": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Represents a group of navigation actions within `SideNavigation`.\nThe `SideNavigationGroup` can only be used inside a `SideNavigation`.\n\n\n\n__Note:__ This is a UI5 Web Component! [SideNavigationGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SideNavigationGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines nested items by passing `SideNavigationItem` to the default slot.\n\n__Supported Node Type/s:__ `Array<SideNavigationItem>`"
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "expanded": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the item is expanded",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the item."
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\nA tooltip attribute should be provided, in order to represent meaning/function,\nwhen the component is collapsed (\"icon only\" design is visualized) or the item text is truncated.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SideNavigationGroupDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SideNavigationItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Represents a navigation action. It can provide sub items.\nThe `SideNavigationItem` is used within `SideNavigation` or `SideNavigationGroup` only.\n\n\n\n__Note:__ This is a UI5 Web Component! [SideNavigationItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SideNavigationItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines nested items by passing `SideNavigationSubItem` to the default slot.\n\n__Supported Node Type/s:__ `Array<SideNavigationSubItem>`"
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SideNavigationItemDomRef, SideNavigationItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is activated either with a click/tap or by using the [Enter] or [Space] keys.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "altKey",
-                "type": "boolean",
-                "description": "Returns whether the \"ALT\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "ctrlKey",
-                "type": "boolean",
-                "description": "Returns whether the \"CTRL\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "metaKey",
-                "type": "boolean",
-                "description": "Returns whether the \"META\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "shiftKey",
-                "type": "boolean",
-                "description": "Returns whether the \"SHIFT\" key was pressed when the event was triggered."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "SideNavigationItemAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n**Note:** Do not use it on parent items, as it will be overridden if the item is in the overflow menu.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "SideNavigationItemDesign | \"Default\" | \"Action\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "Design for items that perform navigation, contain navigation child items, or both."
-              },
-              {
-                "value": "\"Action\"",
-                "description": "Design for items that trigger an action, such as opening a dialog.\n\n**Note:** Items with this design must not have sub-items.\n\n**Note:** Items that open a dialog must set `hasPopup=\"dialog\"` via `accessibilityAttributes` property."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Action\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Item design.\n\n**Note:** Items with \"Action\" design must not have sub-items.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "expanded": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the item is expanded",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "href": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the link target URI. Supports standard hyperlink behavior.\nIf a JavaScript action should be triggered,\nthis should not be set, but instead an event handler\nfor the `click` event should be registered.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**."
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon of the item.\n\n**Note:** Icons on second-level (child) navigation items are not recommended according to the design specification.\n\nThe SAP-icons font provides numerous options.\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the item is selected.\n\n**Note:** Items that have a set `href` and `target` set to `_blank` should not be selectable.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "target": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the component target.\n\nPossible values:\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `framename`\n\n**Note:** Items that have a defined `href` and `target`\nattribute set to `_blank` should not be selectable.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**."
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the item."
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\nA tooltip attribute should be provided, in order to represent meaning/function,\nwhen the component is collapsed (\"icon only\" design is visualized) or the item text is truncated.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**."
-        },
-        "unselectable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the navigation item is selectable. By default, all items are selectable unless specifically marked as unselectable.\n\nWhen a parent item is marked as unselectable, selecting it will only expand or collapse its sub-items.\nTo improve user experience do not mix unselectable parent items with selectable parent items in a single side navigation.\n\n\n**Guidelines**:\n- Items with an assigned `href` and a target of `_blank` should be marked as unselectable.\n- Items that trigger actions (with design \"Action\") should be marked as unselectable.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SideNavigationItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SideNavigationSubItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Represents a single navigation action within `SideNavigationItem`.\nThe `SideNavigationSubItem` is intended to be used inside a `SideNavigationItem` only.\n\n\n\n__Note:__ This is a UI5 Web Component! [SideNavigationSubItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SideNavigationSubItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SideNavigationSubItemDomRef, SideNavigationItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is activated either with a click/tap or by using the [Enter] or [Space] keys.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "altKey",
-                "type": "boolean",
-                "description": "Returns whether the \"ALT\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "ctrlKey",
-                "type": "boolean",
-                "description": "Returns whether the \"CTRL\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "metaKey",
-                "type": "boolean",
-                "description": "Returns whether the \"META\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "shiftKey",
-                "type": "boolean",
-                "description": "Returns whether the \"SHIFT\" key was pressed when the event was triggered."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "SideNavigationItemAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n**Note:** Do not use it on parent items, as it will be overridden if the item is in the overflow menu.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "SideNavigationItemDesign | \"Default\" | \"Action\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "Design for items that perform navigation, contain navigation child items, or both."
-              },
-              {
-                "value": "\"Action\"",
-                "description": "Design for items that trigger an action, such as opening a dialog.\n\n**Note:** Items with this design must not have sub-items.\n\n**Note:** Items that open a dialog must set `hasPopup=\"dialog\"` via `accessibilityAttributes` property."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Action\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Item design.\n\n**Note:** Items with \"Action\" design must not have sub-items.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "href": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the link target URI. Supports standard hyperlink behavior.\nIf a JavaScript action should be triggered,\nthis should not be set, but instead an event handler\nfor the `click` event should be registered.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**."
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon of the item.\n\n**Note:** Icons on second-level (child) navigation items are not recommended according to the design specification.\n\nThe SAP-icons font provides numerous options.\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the item is selected.\n\n**Note:** Items that have a set `href` and `target` set to `_blank` should not be selectable.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "target": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the component target.\n\nPossible values:\n\n- `_self`\n- `_top`\n- `_blank`\n- `_parent`\n- `framename`\n\n**Note:** Items that have a defined `href` and `target`\nattribute set to `_blank` should not be selectable.\n\n**Note:** Available since [v1.19.0](https://github.com/UI5/webcomponents/releases/tag/v1.19.0) of **@ui5/webcomponents-fiori**."
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the item."
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\nA tooltip attribute should be provided, in order to represent meaning/function,\nwhen the component is collapsed (\"icon only\" design is visualized) or the item text is truncated.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**."
-        },
-        "unselectable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the navigation item is selectable. By default, all items are selectable unless specifically marked as unselectable.\n\nWhen a parent item is marked as unselectable, selecting it will only expand or collapse its sub-items.\nTo improve user experience do not mix unselectable parent items with selectable parent items in a single side navigation.\n\n\n**Guidelines**:\n- Items with an assigned `href` and a target of `_blank` should be marked as unselectable.\n- Items that trigger actions (with design \"Action\") should be marked as unselectable.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SideNavigationSubItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Slider": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The Slider component represents a numerical range and a handle (grip).\nThe purpose of the component is to enable visual selection of a value in\na continuous numerical range by moving an adjustable handle.\n\n### Structure\nThe most important properties of the Slider are:\n\n- min - The minimum value of the slider range.\n- max - The maximum value of the slider range.\n- value - The current value of the slider range.\n- step - Determines the increments in which the slider will move.\n- showTooltip - Determines if a tooltip should be displayed above the handle.\n- showTickmarks - Displays a visual divider between the step values.\n- labelInterval - Labels some or all of the tickmarks with their values.\n\n### Usage\nThe most common use case is to select values on a continuous numerical scale (e.g. temperature, volume, etc. ).\n\n### Responsive Behavior\nThe `Slider` component adjusts to the size of its parent container by recalculating and\nresizing the width of the control. You can move the slider handle in several different ways:\n\n- Drag and drop the handle to the desired value.\n- Click/tap on the range bar to move the handle to that location.\n\n### Keyboard Handling\n\n- `Left or Down Arrow` - Moves the handle one step to the left, effectively decreasing the component's value by `step` amount;\n- `Right or Up Arrow` - Moves the handle one step to the right, effectively increasing the component's value by `step` amount;\n- `Left or Down Arrow + Ctrl/Cmd` - Moves the handle to the left with step equal to 1/10th of the entire range, effectively decreasing the component's value by 1/10th of the range;\n- `Right or Up Arrow + Ctrl/Cmd` - Moves the handle to the right with step equal to 1/10th of the entire range, effectively increasing the component's value by 1/10th of the range;\n- `Plus` - Same as `Right or Up Arrow`;\n- `Minus` - Same as `Left or Down Arrow`;\n- `Home` - Moves the handle to the beginning of the range;\n- `End` - Moves the handle to the end of the range;\n- `Page Up` - Same as `Right or Up + Ctrl/Cmd`;\n- `Page Down` - Same as `Left or Down + Ctrl/Cmd`;\n- `Escape` - Resets the value property after interaction, to the position prior the component's focusing;\n\n\n\n__Note:__ This is a UI5 Web Component! [Slider UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Slider) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SliderDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value changes and the user has finished interacting with the slider.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SliderDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value changes due to user interaction that is not yet finished - during mouse/touch dragging.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents**."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the slider is in disabled state.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "editableTooltip": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether input fields should be used as tooltips for the handles.\n\n**Note:** Setting this option to true will only work if showTooltip is set to true.\n**Note:** In order for the component to comply with the accessibility standard, it is recommended to set the editableTooltip property to true.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "labelInterval": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Displays a label with a value on every N-th step.\n\n**Note:** The step and tickmarks properties must be enabled.\nExample - if the step value is set to 2 and the label interval is also specified to 2 - then every second\ntickmark will be labelled, which means every 4th value number.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "max": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the maximum value of the slider.",
-          "defaultValue": {
-            "value": "100"
-          }
-        },
-        "min": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the minimum value of the slider.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
-        },
-        "showTickmarks": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Enables tickmarks visualization for each step.\n\n**Note:** The step must be a positive number.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showTooltip": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Enables handle tooltip displaying the current value.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "step": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the size of the slider's selection intervals (e.g. min = 0, max = 10, step = 5 would result in possible selection of the values 0, 5, 10).\n\n**Note:** If set to 0 the slider handle movement is disabled.",
-          "defaultValue": {
-            "value": "1"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Current value of the slider",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SliderDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "handle",
-          "description": "Used to style the handle of the `ui5-slider`."
-        },
-        {
-          "name": "progress-bar",
-          "description": "Used to style the progress bar, which shows the progress of the `ui5-slider`."
-        },
-        {
-          "name": "progress-container",
-          "description": "Used to style the progress container, the horizontal bar that visually represents the range between the minimum and maximum values, of the `ui5-slider`."
-        }
-      ]
-    },
-    "SortItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `SortItem` component defines the sorting criteria for data in `ViewSettingsDialog`.\nIt represents a single sort option that users can select to organize data in ascending or descending order.\n\n### Usage\n\nThe `SortItem` is used within the `ViewSettingsDialog` to provide sorting options.\nEach sort item represents a column or field by which data can be sorted.\n\n\n\n__Note:__ This is a UI5 Web Component! [SortItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/SortItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the sort item is selected.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the sort item."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SortItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SpecialCalendarDate": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `SpecialCalendarDate` component defines a special calendar date to be used inside `Calendar`,\nwhich is visually distinguished from the rest of the dates.\n\n__Note:__ This is a UI5 Web Component! [SpecialCalendarDate UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SpecialCalendarDate) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "CalendarLegendItemType | \"Today\" | \"Selected\" | \"None\" | \"Working\" | \"NonWorking\" | \"Type01\" | \"Type02\" | \"Type03\" | \"Type04\" | \"Type05\" | \"Type06\" | ... 13 more ... | \"Type20\"",
-            "value": [
-              {
-                "value": "\"Today\"",
-                "description": "Represents the \"Today\" item in the calendar legend."
-              },
-              {
-                "value": "\"Selected\"",
-                "description": "Represents the \"Selected\" item in the calendar legend."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Set when no type is set."
-              },
-              {
-                "value": "\"Working\"",
-                "description": "Represents the \"Working\" item in the calendar legend."
-              },
-              {
-                "value": "\"NonWorking\"",
-                "description": "Represents the \"NonWorking\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type01\"",
-                "description": "Represents the \"Type01\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type02\"",
-                "description": "Represents the \"Type02\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type03\"",
-                "description": "Represents the \"Type03\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type04\"",
-                "description": "Represents the \"Type04\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type05\"",
-                "description": "Represents the \"Type05\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type06\"",
-                "description": "Represents the \"Type06\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type07\"",
-                "description": "Represents the \"Type07\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type08\"",
-                "description": "Represents the \"Type08\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type09\"",
-                "description": "Represents the \"Type09\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type10\"",
-                "description": "Represents the \"Type10\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type11\"",
-                "description": "Represents the \"Type11\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type12\"",
-                "description": "Represents the \"Type12\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type13\"",
-                "description": "Represents the \"Type13\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type14\"",
-                "description": "Represents the \"Type14\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type15\"",
-                "description": "Represents the \"Type15\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type16\"",
-                "description": "Represents the \"Type16\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type17\"",
-                "description": "Represents the \"Type17\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type18\"",
-                "description": "Represents the \"Type18\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type19\"",
-                "description": "Represents the \"Type19\" item in the calendar legend."
-              },
-              {
-                "value": "\"Type20\"",
-                "description": "Represents the \"Type20\" item in the calendar legend."
-              },
-              {
-                "value": "\"Today\""
-              },
-              {
-                "value": "\"Selected\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Working\""
-              },
-              {
-                "value": "\"NonWorking\""
-              },
-              {
-                "value": "\"Type01\""
-              },
-              {
-                "value": "\"Type02\""
-              },
-              {
-                "value": "\"Type03\""
-              },
-              {
-                "value": "\"Type04\""
-              },
-              {
-                "value": "\"Type05\""
-              },
-              {
-                "value": "\"Type06\""
-              },
-              {
-                "value": "\"Type07\""
-              },
-              {
-                "value": "\"Type08\""
-              },
-              {
-                "value": "\"Type09\""
-              },
-              {
-                "value": "\"Type10\""
-              },
-              {
-                "value": "\"Type11\""
-              },
-              {
-                "value": "\"Type12\""
-              },
-              {
-                "value": "\"Type13\""
-              },
-              {
-                "value": "\"Type14\""
-              },
-              {
-                "value": "\"Type15\""
-              },
-              {
-                "value": "\"Type16\""
-              },
-              {
-                "value": "\"Type17\""
-              },
-              {
-                "value": "\"Type18\""
-              },
-              {
-                "value": "\"Type19\""
-              },
-              {
-                "value": "\"Type20\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the type of the special date.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "The date formatted according to the `formatPattern` property\nof the `Calendar` that hosts the component."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SpecialCalendarDateDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SplitButton": {
-      "package": "@ui5/webcomponents-react",
-      "description": "`SplitButton` enables users to trigger actions. It is constructed of two separate actions -\ndefault action and arrow action that can be activated by clicking or tapping, or by\npressing certain keyboard keys - `Space` or `Enter` for default action,\nand `Arrow Down` or `Arrow Up` for arrow action.\n\n### Usage\n\n`SplitButton` consists two separate buttons:\n\n- for the first one (default action) you can define some `text` or an `icon`, or both.\n- the second one (arrow action) contains only `slim-arrow-down` icon.\n\nYou can choose a `design` from a set of predefined types (the same as for ui5-button) that offer\ndifferent styling to correspond to the triggered action. Both text and arrow actions have the same design.\n\nYou can set the `SplitButton` as enabled or disabled. Both parts of an enabled\n`SplitButton` can be pressed by clicking or tapping it, or by certain keys, which changes\nthe style to provide visual feedback to the user that it is pressed or hovered over with\nthe mouse cursor. A disabled `SplitButton` appears inactive and any of the two buttons\ncannot be pressed.\n\n### Keyboard Handling\n\n- `Space` or `Enter` - triggers the default action\n- `Shift` or `Escape` - if `Space` is pressed, releases the default action button without triggering the click event.\n- `Arrow Down`, `Arrow Up`, `Alt`+`Arrow Down`, `Alt`+`Arrow Up`, or `F4` - triggers the arrow action\nThere are separate events that are fired on activating of `SplitButton` parts:\n\n- `click` for the first button (default action)\n- `arrow-click` for the second button (arrow action)\n\n\n\n__Note:__ This is a UI5 Web Component! [SplitButton UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SplitButton) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "onArrowClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SplitButtonDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on the arrow action.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SplitButtonDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on the default action.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "SplitButtonAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe `accessibilityAttributes` property accepts an object with the following optional fields:\n\n- **root**: Attributes that will be applied to the main (text) button.\n  - **hasPopup**: Indicates the presence and type of popup triggered by the button.\n    Accepts string values: `\"dialog\"`, `\"grid\"`, `\"listbox\"`, `\"menu\"`, or `\"tree\"`.\n  - **roleDescription**: Provides a human-readable description for the role of the button.\n    Accepts any string value.\n  - **title**: Specifies a tooltip or description for screen readers.\n    Accepts any string value.\n\t- **ariaKeyShortcuts**: Defines keyboard shortcuts that activate or give focus to the button.\n\n- **arrowButton**: Attributes applied specifically to the arrow (split) button.\n  - **hasPopup**: Indicates the presence and type of popup triggered by the arrow button.\n    Accepts string values: `\"dialog\"`, `\"grid\"`, `\"listbox\"`, `\"menu\"`, or `\"tree\"`.\n  - **expanded**: Indicates whether the popup triggered by the arrow button is currently expanded.\n    Accepts boolean values: `true` or `false`.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "activeArrowButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the arrow button should have the active state styles or not.\n\n**Note:** Available since [v1.21.0](https://github.com/UI5/webcomponents/releases/tag/v1.21.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "ButtonDesign | \"Default\" | \"Positive\" | \"Negative\" | \"Transparent\" | \"Emphasized\" | \"Attention\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "default type (no special styling)"
-              },
-              {
-                "value": "\"Positive\"",
-                "description": "accept type (green button)"
-              },
-              {
-                "value": "\"Negative\"",
-                "description": "reject style (red button)"
-              },
-              {
-                "value": "\"Transparent\"",
-                "description": "transparent type"
-              },
-              {
-                "value": "\"Emphasized\"",
-                "description": "emphasized type"
-              },
-              {
-                "value": "\"Attention\"",
-                "description": "attention type"
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Transparent\""
-              },
-              {
-                "value": "\"Emphasized\""
-              },
-              {
-                "value": "\"Attention\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component design.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\nExample:\n\nSee all available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SplitButtonDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "button",
-          "description": "Used to style the native button element"
-        },
-        {
-          "name": "endIcon",
-          "description": "Used to style the end icon in the native button element"
-        },
-        {
-          "name": "icon",
-          "description": "Used to style the icon in the native button element"
-        }
-      ]
-    },
-    "StepInput": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `StepInput` consists of an input field and buttons with icons to increase/decrease the value\nwith the predefined step.\n\nThe user can change the value of the component by pressing the increase/decrease buttons,\nby typing a number directly, by using the keyboard up/down and page up/down,\nor by using the mouse scroll wheel. Decimal values are supported.\n\n### Usage\n\nThe default step is 1 but the app developer can set a different one.\n\nApp developers can set a maximum and minimum value for the `StepInput`.\nThe increase/decrease button and the up/down keyboard navigation become disabled when\nthe value reaches the max/min or a new value is entered from the input which is greater/less than the max/min.\n\n#### When to use:\n\n- To adjust amounts, quantities, or other values quickly.\n- To adjust values for a specific step.\n\n#### When not to use:\n\n- To enter a static number (for example, postal code, phone number, or ID). In this case,\nuse the regular `Input` instead.\n- To display a value that rarely needs to be adjusted and does not pertain to a particular step.\nIn this case, use the regular `Input` instead.\n- To enter dates and times. In this case, use date/time related components instead.\n\n\n\n__Note:__ This is a UI5 Web Component! [StepInput UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/StepInput) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<StepInputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<StepInputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the component changes at each keystroke.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onValueStateChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<StepInputDomRef, StepInputValueStateChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the value state of the component is updated internally.\nThe event is preventable, meaning that if it's default action is\nprevented, the component will not update the value state.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in between the min and max value."
-              },
-              {
-                "name": "valueState",
-                "type": "string",
-                "description": "The new `valueState` that will be set."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is displayed as disabled.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "max": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines a maximum value of the component."
-        },
-        "min": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines a minimum value of the component."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint, intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** When no placeholder is set, the format pattern is displayed as a placeholder.\nPassing an empty string as the value of this property will make the component appear empty - without placeholder or format pattern."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is displayed as read-only.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "step": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines a step of increasing/decreasing the value of the component.",
-          "defaultValue": {
-            "value": "1"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines a value of the component.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "valuePrecision": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Determines the number of digits after the decimal point of the component.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<StepInputDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SuggestionItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `SuggestionItem` represents the suggestion item of the `Input`.\n\n__Note:__ This is a UI5 Web Component! [SuggestionItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SuggestionItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "additionalText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `additionalText`, displayed in the end of the item."
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the component."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SuggestionItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SuggestionItemCustom": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `SuggestionItemCustom` is type of suggestion item,\nthat can be used to place suggestion items with custom content in the input.\nThe text property is considered only for autocomplete.\nIn case the user needs highlighting functionality, check \"@ui5/webcomponents-base/dist/util/generateHighlightedMarkup.js\"\n\n__Note:__ This is a UI5 Web Component! [SuggestionItemCustom UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SuggestionItemCustom) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the `SuggestionItemCustom`.\n**Note:** The text property is considered only for autocomplete."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SuggestionItemCustomDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "SuggestionItemGroup": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `SuggestionItemGroup` is type of suggestion item,\nthat can be used to split the `Input` suggestions into groups.\n\n__Note:__ This is a UI5 Web Component! [SuggestionItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/SuggestionItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the <code>ui5-suggestion-item-group</code>.\n\n__Supported Node Type/s:__ `Array<SuggestionListItem>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
-        },
-        "onMove": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SuggestionItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMoveOver": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SuggestionItemGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "headerAccessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the header."
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text of the <code>ui5-li-group</code>."
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "WrappingType | \"None\" | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ExpandableText` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SuggestionItemGroupDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "header",
-          "description": "Used to style the header item of the group"
-        },
-        {
-          "name": "title",
-          "description": "Used to style the title of the group header"
-        }
-      ]
-    },
-    "Switch": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Switch` component is used for changing between binary states.\n\nThe component can display texts, that will be switched, based on the component state, via the `textOn` and `textOff` properties,\nbut texts longer than 3 letters will be cutted off.\n\nHowever, users are able to customize the width of `Switch` with pure CSS (`<Switch style=\"width: 200px\">`), and set widths, depending on the texts they would use.\n\nNote: the component would not automatically stretch to fit the whole text width.\n\n### Keyboard Handling\nThe state can be changed by pressing the Space and Enter keys.\n\n\n\n__Note:__ This is a UI5 Web Component! [Switch UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Switch) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<SwitchDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component checked state changes.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Sets the accessible ARIA name of the component.\n\n**Note**: We recommend that you set an accessibleNameRef pointing to an external label or at least an `accessibleName`.\nProviding an `accessibleNameRef` or an `accessibleName` is mandatory in the cases when `textOn` and `textOff` properties aren't set.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note**: We recommend that you set an accessibleNameRef pointing to an external label or at least an `accessibleName`.\nProviding an `accessibleNameRef` or an `accessibleName` is mandatory in the cases when `textOn` and `textOff` properties aren't set.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "checked": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the component is checked.\n\n**Note:** The property can be changed with user interaction,\neither by cliking the component, or by pressing the `Enter` or `Space` key.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "SwitchDesign | \"Textual\" | \"Graphical\"",
-            "value": [
-              {
-                "value": "\"Textual\"",
-                "description": "Defines the Switch as Textual"
-              },
-              {
-                "value": "\"Graphical\"",
-                "description": "Defines the Switch as Graphical"
-              },
-              {
-                "value": "\"Textual\""
-              },
-              {
-                "value": "\"Graphical\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component design.\n\n**Note:** If `Graphical` type is set,\npositive and negative icons will replace the `textOn` and `textOff`.",
-          "defaultValue": {
-            "value": "\"Textual\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\n\n**Note:** A disabled component is noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v1.16.0](https://github.com/UI5/webcomponents/releases/tag/v1.16.0) of **@ui5/webcomponents**."
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.\n\n**Note:** Available since [v1.16.0](https://github.com/UI5/webcomponents/releases/tag/v1.16.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "textOff": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text, displayed when the component is not checked.\n\n**Note:** We recommend using short texts, up to 3 letters (larger texts would be cut off)."
-        },
-        "textOn": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text, displayed when the component is checked.\n\n**Note:** We recommend using short texts, up to 3 letters (larger texts would be cut off)."
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\n**Note:** If applicable an external label reference should always be the preferred option to provide context to the `Switch` component over a tooltip.\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**."
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the form value of the component.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents**."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<SwitchDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "handle",
-          "description": "Used to style the handle of the switch"
-        },
-        {
-          "name": "slider",
-          "description": "Used to style the track, where the handle is being slid"
-        },
-        {
-          "name": "text-off",
-          "description": "Used to style the `textOff` property text"
-        },
-        {
-          "name": "text-on",
-          "description": "Used to style the `textOn` property text"
-        }
-      ]
-    },
-    "Tab": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Tab` represents a selectable item inside a `TabContainer`.\nIt defines both the item in the tab strip (top part of the `TabContainer`) and the\ncontent that is presented to the user once the tab is selected.\n\n__Note:__ This is a UI5 Web Component! [Tab UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Tab) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Holds the content associated with this tab.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "items": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines hierarchies with nested sub tabs.\n\n**Note:** Use `Tab` and `TabSeparator` for the intended design.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"items\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ITab>`"
-        },
-        "additionalText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Represents the \"additionalText\" text, which is displayed in the tab. In the cases when in the same time there are tabs with icons and tabs without icons, if a tab has no icon the \"additionalText\" is displayed larger."
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "SemanticColor | \"Default\" | \"Positive\" | \"Negative\" | \"Critical\" | \"Neutral\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "Default color (brand color)"
-              },
-              {
-                "value": "\"Positive\"",
-                "description": "Positive color"
-              },
-              {
-                "value": "\"Negative\"",
-                "description": "Negative color"
-              },
-              {
-                "value": "\"Critical\"",
-                "description": "Critical color"
-              },
-              {
-                "value": "\"Neutral\"",
-                "description": "Neutral color."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Neutral\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component's design color.\n\nThe design is applied to:\n\n- the component icon\n- the `text` when the component overflows\n- the tab selection line\n\nAvailable designs are: `\"Default\"`, `\"Neutral\"`, `\"Positive\"`, `\"Critical\"` and `\"Negative\"`.\n\n**Note:** The design depends on the current theme.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Disabled tabs can't be selected.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon source URI to be displayed as graphical element within the component.\nThe SAP-icons font provides numerous built-in icons.\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "movable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the tab is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Specifies if the component is selected.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "The text to be displayed for the item."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TabDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "getDomRefInStrip",
-          "description": "Returns the DOM reference of the tab that is placed in the header. **Note:** Tabs, placed in the `items` slot of other tabs are not shown in the header. Calling this method on such tabs will return `undefined`. **Note:** If you need a DOM ref to the tab content please use the `getDomRef` method.",
-          "params": [],
-          "returns": {
-            "type": "HTMLElement | undefined"
-          }
-        }
-      ]
-    },
-    "TabContainer": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TabContainer` represents a collection of tabs with associated content.\nNavigation through the tabs changes the content display of the currently active content area.\nA tab can be labeled with text only, or icons with text.\n\n### Structure\n\nThe `TabContainer` can hold two types of entities:\n\n- `Tab` - contains all the information on an item (text and icon)\n- `TabSeparator` - used to separate tabs with a line\n\n### Hierarchies\nMultiple sub tabs could be placed underneath one main tab. Nesting allows deeper hierarchies with indentations\nto indicate the level of each nested tab. When a tab has both sub tabs and own content its click area is split\nto allow the user to display the content or alternatively to expand / collapse the list of sub tabs.\n\n### Keyboard Handling\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n\n\n`import \"@ui5/webcomponents/dist/Tab.js\";` (for `Tab`)\n\n`import \"@ui5/webcomponents/dist/TabSeparator.js\";` (for `TabSeparator`)\n\n__Note:__ This is a UI5 Web Component! [TabContainer UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TabContainer) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the tabs.\n\n**Note:** Use `Tab` and `TabSeparator` for the intended design.\n\n__Supported Node Type/s:__ `Array<ITab>`"
-        },
-        "overflowButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the button which will open the overflow menu. If nothing is provided to this slot,\nthe default button will be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"overflowButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "startOverflowButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the button which will open the start overflow menu if available. If nothing is provided to this slot,\nthe default button will be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"startOverflowButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "onMove": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TabContainerDomRef, TabContainerMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when element is moved to the tab container.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMoveOver": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TabContainerDomRef, TabContainerMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when element is being moved over the tab container.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onTabSelect": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TabContainerDomRef, TabContainerTabSelectEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a tab is selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "tab",
-                "type": "Tab",
-                "description": "The selected `tab`."
-              },
-              {
-                "name": "tabIndex",
-                "type": "Integer",
-                "description": "The selected `tab` index in the flattened array of all tabs and their subTabs, provided by the `allItems` getter."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "collapsed": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the tab content is collapsed.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "contentBackgroundDesign": {
-          "type": {
-            "name": "enum",
-            "raw": "BackgroundDesign | \"Solid\" | \"Transparent\" | \"Translucent\"",
-            "value": [
-              {
-                "value": "\"Solid\"",
-                "description": "A solid background color dependent on the theme."
-              },
-              {
-                "value": "\"Transparent\"",
-                "description": "Transparent background."
-              },
-              {
-                "value": "\"Translucent\"",
-                "description": "A translucent background depending on the opacity value of the theme."
-              },
-              {
-                "value": "\"Solid\""
-              },
-              {
-                "value": "\"Transparent\""
-              },
-              {
-                "value": "\"Translucent\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Sets the background color of the Tab Container's content as `Solid`, `Transparent`, or `Translucent`.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Solid\""
-          }
-        },
-        "headerBackgroundDesign": {
-          "type": {
-            "name": "enum",
-            "raw": "BackgroundDesign | \"Solid\" | \"Transparent\" | \"Translucent\"",
-            "value": [
-              {
-                "value": "\"Solid\"",
-                "description": "A solid background color dependent on the theme."
-              },
-              {
-                "value": "\"Transparent\"",
-                "description": "Transparent background."
-              },
-              {
-                "value": "\"Translucent\"",
-                "description": "A translucent background depending on the opacity value of the theme."
-              },
-              {
-                "value": "\"Solid\""
-              },
-              {
-                "value": "\"Transparent\""
-              },
-              {
-                "value": "\"Translucent\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Sets the background color of the Tab Container's header as `Solid`, `Transparent`, or `Translucent`.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Solid\""
-          }
-        },
-        "noAutoSelection": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if automatic tab selection is deactivated.\n\n**Note:** By default, if none of the child tabs have the `selected` property set, the first tab will be automatically selected.\nSetting this property to `true` allows preventing this behavior.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "overflowMode": {
-          "type": {
-            "name": "enum",
-            "raw": "OverflowMode | \"End\" | \"StartAndEnd\"",
-            "value": [
-              {
-                "value": "\"End\"",
-                "description": "End type is used if there should be only one overflow with hidden the tabs at the end of the tab container."
-              },
-              {
-                "value": "\"StartAndEnd\"",
-                "description": "StartAndEnd type is used if there should be two overflows on both ends of the tab container."
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"StartAndEnd\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the overflow mode of the header (the tab strip). If you have a large number of tabs, only the tabs that can fit on screen will be visible.\nAll other tabs that can 't fit on the screen are available in an overflow tab \"More\".\n\n**Note:**\nOnly one overflow at the end would be displayed by default,\nbut when set to `StartAndEnd`, there will be two overflows on both ends, and tab order will not change on tab selection.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"End\""
-          }
-        },
-        "tabLayout": {
-          "type": {
-            "name": "enum",
-            "raw": "TabLayout | \"Inline\" | \"Standard\"",
-            "value": [
-              {
-                "value": "\"Inline\"",
-                "description": "Inline type, the tab \"main text\" and \"additionalText\" are displayed horizotally."
-              },
-              {
-                "value": "\"Standard\"",
-                "description": "Standard type, the tab \"main text\" and \"additionalText\" are displayed vertically."
-              },
-              {
-                "value": "\"Inline\""
-              },
-              {
-                "value": "\"Standard\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the alignment of the content and the `additionalText` of a tab.\n\n**Note:**\nThe content and the `additionalText` would be displayed vertically by default,\nbut when set to `Inline`, they would be displayed horizontally.",
-          "defaultValue": {
-            "value": "\"Standard\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TabContainerDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "content",
-          "description": "Used to style the content of the component"
-        },
-        {
-          "name": "tabstrip",
-          "description": "Used to style the tabstrip of the component"
-        }
-      ]
-    },
-    "TabSeparator": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TabSeparator` represents a vertical line to separate tabs inside a `TabContainer`.\n\n__Note:__ This is a UI5 Web Component! [TabSeparator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TabSeparator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TabSeparatorDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "getDomRefInStrip",
-          "description": "Returns the DOM reference of the separator that is placed in the header. **Note:** Separators, placed in the `items` slot of other tabs are not shown in the header. Calling this method on such separators will return `undefined`.",
-          "params": [],
-          "returns": {
-            "type": "HTMLElement | undefined"
-          }
-        }
-      ]
-    },
-    "Table": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Table` component provides a set of sophisticated features for displaying and dealing with vast amounts of data in a responsive manner.\nTo render the `Table`, you need to define the columns and rows. You can use the provided `TableHeaderRow` and `TableRow` components for this purpose.\n\n### Features\n\nThe `Table` can be enhanced in its functionalities by applying different features.\nFeatures can be slotted into the `features` slot, to enable them in the component.\nFeatures need to be imported separately, as they are not enabled by default.\n\nThe following features are currently available:\n\n* [TableSelectionMulti](../TableSelectionMulti) - adds multi-selection capabilities to the table\n* [TableSelectionSingle](../TableSelectionSingle) - adds single-selection capabilities to the table\n* [TableGrowing](../TableGrowing) - provides growing capabilities to load more data\n* [TableVirtualizer](../TableVirtualizer) - adds virtualization capabilities to the table\n\n### Keyboard Handling\n\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\nFurthermore, you can interact with `Table` via the following keys:\n\nIf the focus is on a row, the following keyboard shortcuts are available:\n* <kbd>Down</kbd> - Navigates down\n* <kbd>Up</kbd> - Navigates up\n* <kbd>Right</kbd> - Selects the first cell of the row\n* <kbd>Space</kbd> - Toggles the selection of the row\n* <kbd>Ctrl/Cmd + A</kbd> - In multi selection mode, toggles the selection of all rows\n* <kbd>Home</kbd> - Navigates to the first row, if the focus is on the first row, navigates to the header row\n* <kbd>End</kbd> - Navigates to the last row, if the focus is on the last row, navigates to the growing button\n* <kbd>Page Up</kbd> - Navigates one page up, if the focus is on the first row, navigates to the header row\n* <kbd>Page Down</kbd> - Navigates one page down, if the focus is on the last row, navigates to the growing button\n* <kbd>F2</kbd> - Focuses the first tabbable element in the row\n* <kbd>F7</kbd> - If focus position is remembered, moves focus to the corresponding focus position row, otherwise to the first tabbable element within the row\n* <kbd>[Shift]Tab</kbd> - Move focus to the element in the tab chain outside the table\n\nIf the focus is on a cell, the following keyboard shortcuts are available:\n* <kbd>Down</kbd> - Navigates down\n* <kbd>Up</kbd> - Navigates up\n* <kbd>Right</kbd> - Navigates right\n* <kbd>Left</kbd> - Navigates left, if the focus is on the first cell of the row, the focus is moved to the row.\n* <kbd>Home</kbd> - Navigates to the first cell of the current row, if the focus is on the first cell, navigates to the corresponding row\n* <kbd>End</kbd> - Navigates to the last cell of the current row, if the focus is on the last cell, navigates to the corresponding row\n* <kbd>Page Up</kbd> - Navigates one page up while keeping the focus in same column\n* <kbd>Page Down</kbd> - Navigates one page down while keeping the focus in same column\n* <kbd>F2</kbd> - Toggles the focus between the first tabbable cell content and the cell\n* <kbd>Enter</kbd> - Focuses the first tabbable cell content\n* <kbd>F7</kbd> - If the focus is on an interactive element inside a row, moves focus to the corresponding row and remembers the focus position of the element within the row\n* <kbd>[Shift]Tab</kbd> - Move focus to the element in the tab chain outside the table\n\nIf the focus is on an interactive cell content, the following keyboard shortcuts are available:\n* <kbd>Down</kbd> - Move the focus to the interactive element in the same column of the previous row, unless the focused element prevents the default\n* <kbd>Up</kbd> - Move the focus to the interactive element in the same column of the next row, unless the focused element prevents the default\n* <kbd>[Shift]Tab</kbd> - Move the focus to the element in the tab chain\n\n### Accessibility\n\nThe `Table` follows the [ARIA grid design pattern](https://www.w3.org/WAI/ARIA/apg/patterns/grid/).\nThis pattern enables cell-based keyboard navigation and, as explained above, we also support row-based keyboard navigation.\nSince the grid design pattern does not inherently provide row-based keyboard behavior, if the focus is on a row, not only the row information but also the corresponding column headers for each cell must be announced.\nThis can only be achieved through a custom accessibility announcement.\nTo support this, UI5 Web Components expose its own accessibility metadata via the `accessibilityInfo` property.\nThe `Table` uses this information to create the required custom announcements dynamically.\nIf you include custom web components inside table cells that are not part of the standard UI5 Web Components set, their accessibility information can be provided using the `data-ui5-acc-text` attribute.\n\n)\\\n`import \"@ui5/webcomponents/dist/TableRow.js\";` (`TableRow`)\\\n`import \"@ui5/webcomponents/dist/TableCell.js\";` (`TableCell`)\\\n`import \"@ui5/webcomponents/dist/TableHeaderRow.js\";` (`TableHeaderRow`)\\\n`import \"@ui5/webcomponents/dist/TableHeaderCell.js\";` (`TableHeaderCell`)\n\n__Note:__ This is a UI5 Web Component! [Table UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Table) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the rows of the component.\n\n**Note:** Use `TableRow` for the intended design.\n\n__Supported Node Type/s:__ `Array<TableRow>`"
-        },
-        "features": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the features of the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"features\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ITableFeature>`"
-        },
-        "headerRow": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header row of the component.\n\n**Note:** Use `TableHeaderRow` for the intended design.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"headerRow\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<TableHeaderRow>`"
-        },
-        "noData": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the custom visualization if there is no data available.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"noData\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onMove": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableDomRef, MoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Notes:**\n\nThe `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\nIf the dragging operation is a cross-browser operation or files are moved to a potential drop target,\nthe `source` parameter will be `null`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "The destination object"
-              },
-              {
-                "name": "originalEvent",
-                "type": "Event",
-                "description": "The original `drop` event"
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "The source object"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMoveOver": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableDomRef, MoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** If the dragging operation is a cross-browser operation or files are moved to a potential drop target,\nthe `source` parameter will be `null`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "The destination object"
-              },
-              {
-                "name": "originalEvent",
-                "type": "Event",
-                "description": "The original `dragover` event"
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "The source object"
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onRowActionClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableDomRef, TableRowActionClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a row action is clicked.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "action",
-                "type": "TableRowActionBase",
-                "description": "The row action instance"
-              },
-              {
-                "name": "row",
-                "type": "TableRow",
-                "description": "The row instance"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onRowClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableDomRef, TableRowClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when an interactive row is clicked.\n\n**Note:** This event is not fired if the `behavior` property of the selection component is set to `RowOnly`.\nIn that case, use the `change` event of the selection component instead.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "row",
-                "type": "TableRow",
-                "description": "The row instance"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Identifies the element (or elements) that labels the component."
-        },
-        "alternateRowColors": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the table rows are displayed with alternating background colors.\n\n**Note:** Available since [v2.17](https://github.com/UI5/webcomponents/releases/tag/v2.17) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the loading indicator should be shown.\n\n**Note:** When the component is loading, it is not interactive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the loading indicator will show up for this component.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "noDataText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text to be displayed when there are no rows in the component."
-        },
-        "overflowMode": {
-          "type": {
-            "name": "enum",
-            "raw": "TableOverflowMode | \"Scroll\" | \"Popin\"",
-            "value": [
-              {
-                "value": "\"Scroll\"",
-                "description": "Shows a scrollbar, when the table cannot fit all columns."
-              },
-              {
-                "value": "\"Popin\"",
-                "description": "Pops in columns, that do not fit into the table anymore."
-              },
-              {
-                "value": "\"Scroll\""
-              },
-              {
-                "value": "\"Popin\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the mode of the <code>ui5-table</code> overflow behavior.\n\nAvailable options are:\n\n<code>Scroll</code> - Columns are shown as regular columns and horizontal scrolling is enabled.\n<code>Popin</code> - Columns are shown as pop-ins instead of regular columns.",
-          "defaultValue": {
-            "value": "\"Scroll\""
-          }
-        },
-        "rowActionCount": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the maximum number of row actions that is displayed, which determines the width of the row action column.\n\n**Note:** It is recommended to use a maximum of 3 row actions, as exceeding this limit may take up too much space on smaller screens.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TableCell": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableCell` represents a cell inside of a `Table`.\nIt is tightly coupled to the `Table` and thus should only be used in the table component.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableCell UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableCell) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "horizontalAlign": {
-          "type": {
-            "name": "enum",
-            "raw": "TableCellHorizontalAlign | \"Left\" | \"Start\" | \"Right\" | \"End\" | \"Center\"",
-            "value": [
-              {
-                "value": "\"Left\""
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"Right\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Left\""
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"Right\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Center\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the horizontal alignment of table cells."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableCellDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TableGrowing": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableGrowing` component is used inside the `Table` to add a growing/data loading functionalities\nto the table.\n\nThe component offers two options:\n* Button - a More button is displayed, clicking it will load more data.\n* Scroll - additional data is loaded automatically when the user scrolls to the end of the table.\n\n### Usage\n\nThe `TableGrowing` component is only used inside the `Table` component as a feature.\nIt has to be slotted inside the `Table` in the `features` slot.\nThe component is not intended to be used as a standalone component.\n\n```html\n<Table>\n\t<TableGrowing mode=\"Button\" text=\"More\" slot=\"features\"></TableGrowing>\n</Table>\n```\n\n**Notes**:\n* When the `TableGrowing` component is used with the `Scroll` mode and the table is currently not scrollable,\nthe component will render a growing button instead to ensure growing capabilities until the table becomes scrollable.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableGrowing UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableGrowing) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onLoadMore": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableGrowingDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the growing button is pressed or the user scrolls to the end of the table.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "mode": {
-          "type": {
-            "name": "enum",
-            "raw": "TableGrowingMode | \"Button\" | \"Scroll\"",
-            "value": [
-              {
-                "value": "\"Button\"",
-                "description": "Renders a growing button, which can be pressed to load more data."
-              },
-              {
-                "value": "\"Scroll\"",
-                "description": "Scroll to load more data.\n\n**Note:** If the table is not scrollable, a growing button will be rendered instead to ensure growing functionality."
-              },
-              {
-                "value": "\"Button\""
-              },
-              {
-                "value": "\"Scroll\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the mode of the <code>ui5-table</code> growing.\n\nAvailable options are:\n\nButton - Shows a More button at the bottom of the table, pressing it will load more rows.\n\nScroll - The rows are loaded automatically by scrolling to the bottom of the table. If the table is not scrollable,\na growing button will be rendered instead to ensure growing functionality.",
-          "defaultValue": {
-            "value": "\"Button\""
-          }
-        },
-        "subtext": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text that will be displayed below the `text` inside the growing button.\nHas no effect when mode is set to Scroll."
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text that will be displayed inside the growing button.\nHas no effect when mode is set to `Scroll`.\n\n**Note:** When not provided and the mode is set to Button, a default text is displayed, corresponding to the\ncurrent language."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableGrowingDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TableHeaderCell": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableHeaderCell` component represents a column in the `Table`.\n\nAs it is tightly coupled to the `Table`, it should only be used in the `TableHeaderRow`\nto ensure correct layout and design.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableHeaderCell UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableHeaderCell) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "action": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the action of the column.\n\n**Note:** While multiple actions are technically possible, this is not supported.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"action\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<TableHeaderCellActionBase>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "horizontalAlign": {
-          "type": {
-            "name": "enum",
-            "raw": "TableCellHorizontalAlign | \"Left\" | \"Start\" | \"Right\" | \"End\" | \"Center\"",
-            "value": [
-              {
-                "value": "\"Left\""
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"Right\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Center\""
-              },
-              {
-                "value": "\"Left\""
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"Right\""
-              },
-              {
-                "value": "\"End\""
-              },
-              {
-                "value": "\"Center\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Determines the horizontal alignment of table cells."
-        },
-        "importance": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the importance of the column.\n\nThis property affects the popin behaviour.\nColumns with higher importance will move into the popin area later then less important\ncolumns.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "minWidth": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the minimum width of the column.\n\nIf the table is in `Popin` mode and the minimum width does not fit anymore,\nthe column will move into the popin.\n\nBy default, the table prevents the column from becoming too small.\nChanging this value to a small value might lead to accessibility issues.\n\n**Note:** This property only takes effect for columns with a [\\<percentage\\>](https://developer.mozilla.org/en-US/docs/Web/CSS/percentage) value\nor the default width."
-        },
-        "popinHidden": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the column is hidden in the popin.\n\n**Note:** Please be aware that hiding the column in the popin might lead to accessibility issues as\nusers might not be able to access the content of the column on small screens.\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "popinText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "The text for the column when it pops in.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**."
-        },
-        "sortIndicator": {
-          "type": {
-            "name": "enum",
-            "raw": "SortOrder | \"None\" | \"Ascending\" | \"Descending\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "Sorting is not applied."
-              },
-              {
-                "value": "\"Ascending\"",
-                "description": "Sorting is applied in ascending order."
-              },
-              {
-                "value": "\"Descending\"",
-                "description": "Sorting is applied in descending order."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Ascending\""
-              },
-              {
-                "value": "\"Descending\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the sort indicator of the column.\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "width": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the width of the column.\n\nBy default, the column will grow and shrink according to the available space.\nThis will distribute the space proportionally among all columns with no specific width set.\n\nSee [\\<length\\>](https://developer.mozilla.org/en-US/docs/Web/CSS/length) and\n[\\<percentage\\>](https://developer.mozilla.org/en-US/docs/Web/CSS/percentage) for possible width values."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableHeaderCellDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TableHeaderCellActionAI": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableHeaderCellActionAI` component defines a dedicated AI action for the table column.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableHeaderCellActionAI UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableHeaderCellActionAI) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableHeaderCellActionAIDomRef, TableHeaderCellActionClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a header cell action is clicked.\n\n**Note:** Available since [v2.8.0](https://github.com/UI5/webcomponents/releases/tag/v2.8.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "targetRef",
-                "type": "HTMLElement",
-                "description": "The reference to the element that triggered the event"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableHeaderCellActionAIDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TableHeaderRow": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableHeaderRow` component represents the table headers of a `Table`.\n\nIt is tightly coupled to the `Table` and should therefore be used in the `Table` only.\nThe header row is placed in the `headerRow` slot of the table.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableHeaderRow UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableHeaderRow) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the cells of the component.\n\n**Note:** Use `TableHeaderCell` for the intended design.\n\n__Supported Node Type/s:__ `Array<TableHeaderCell>`"
-        },
-        "sticky": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Sticks the `TableHeaderRow` to the top of a table.\n\nNote: If used in combination with overflowMode \"Scroll\", the table needs a defined height for the sticky header to work as expected.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableHeaderRowDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TableRow": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableRow` component represents a row in the `Table`.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableRow UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableRow) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "actions": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the actions of the component.\n\n**Note:** Use `TableRowAction` or `TableRowActionNavigation` for the intended design.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"actions\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<TableRowActionBase>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the cells of the component.\n\n**Note:** Use `TableCell` for the intended design.\n\n__Supported Node Type/s:__ `Array<TableCell>`"
-        },
-        "interactive": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the interactive state of the row.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "movable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the row is movable.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "navigated": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the navigated state of the row.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "position": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the 0-based position of the row related to the total number of rows within the table when the `TableVirtualizer` feature is used.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
-        },
-        "rowKey": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Unique identifier of the row.\n\n**Note:** For selection features to work properly, this property is mandatory, and its value must not contain spaces."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableRowDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TableRowAction": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableRowAction` component defines an action for table rows.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableRowAction UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableRowAction) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableRowActionDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when a row action is clicked.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon of the row action.\n\n**Note:** For row actions to work properly, this property is mandatory.\n\n**Note:** SAP-icons font provides numerous built-in icons. To find all the available icons, see the\n[Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "invisible": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the visibility of the row action.\n\n**Note:** Invisible row actions still take up space, allowing to hide the action while maintaining its position.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the row action.\n\n**Note:** For row actions to work properly, this property is mandatory."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableRowActionDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TableRowActionNavigation": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableRowActionNavigation` component defines a navigation action for table rows.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableRowActionNavigation UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableRowActionNavigation) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableRowActionNavigationDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when a row action is clicked.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "interactive": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the interactive state of the navigation action.\n@deprecated As of version 2.20.0, the navigation icon is deprecated.\nFor better accessibility, the interactive mode which renders a button, must be used instead. To handle the action, attach a listener to the `click` event.\nIf the navigation should be triggered when a row is pressed, set the row's `interactive` property and use the `row-click` event of the `ui5-table`.\nThis property will be removed in a future release.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "invisible": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the visibility of the row action.\n\n**Note:** Invisible row actions still take up space, allowing to hide the action while maintaining its position.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableRowActionNavigationDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TableSelection": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableSelection` component is used inside the `Table` to add key-based selection capabilities to the `Table`.\n\nThe component offers three selection modes:\n* Single - select a single row.\n* Multiple - select multiple rows.\n* None - no selection active.\n\nAs the selection is key-based, `TableRow` components need to define a unique `row-key` property.\n\n### Usage\n\nThe `TableSelection` component is only used inside the `Table` component as a feature.\nIt has to be slotted inside the `Table` in the `features` slot.\nThe component is not intended to be used as a standalone component.\n\n```html\n<Table>\n\t<TableSelection mode=\"Multiple\" slot=\"features\"></TableSelection>\n</Table>\n```\n\n\n\n__Note:__ This is a UI5 Web Component! [TableSelection UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableSelection) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableSelectionDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the selection is changed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "mode": {
-          "type": {
-            "name": "enum",
-            "raw": "TableSelectionMode | \"None\" | \"Single\" | \"Multiple\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "Default mode (no selection)."
-              },
-              {
-                "value": "\"Single\"",
-                "description": "Single selection mode (only one table row can be selected)."
-              },
-              {
-                "value": "\"Multiple\"",
-                "description": "Multi selection mode (more than one table row can be selected)."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Single\""
-              },
-              {
-                "value": "\"Multiple\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the selection mode.",
-          "defaultValue": {
-            "value": "\"Multiple\""
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the selected rows separated by a space."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableSelectionDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TableSelectionMulti": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableSelectionMulti` component is used inside the `Table` to add multi-selection capabilities to the `Table`.\nSince selection is key-based, each `TableRow` must define a unique `row-key` property.\n\n### Usage\n\nThe `TableSelectionMulti` component is a feature designed exclusively for use within the `Table` component.\nIt must be placed inside the `features` slot of `Table`.\nThis component is not intended for standalone use.\n\n```html\n<Table>\n\t<TableSelectionMulti slot=\"features\" selected=\"Row1 Row3\"></TableSelectionMulti>\n</Table>\n```\n\n\n\n__Note:__ This is a UI5 Web Component! [TableSelectionMulti UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableSelectionMulti) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableSelectionMultiDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the selection is changed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "behavior": {
-          "type": {
-            "name": "enum",
-            "raw": "TableSelectionBehavior | \"RowSelector\" | \"RowOnly\"",
-            "value": [
-              {
-                "value": "\"RowSelector\"",
-                "description": "Rows can only be selected by using the row selector column."
-              },
-              {
-                "value": "\"RowOnly\"",
-                "description": "Rows can only be selected by clicking directly on the row, as the row selector column is hidden.\n\n**Note:** In this mode, the `row-click` event of the `ui5-table` component is not fired."
-              },
-              {
-                "value": "\"RowSelector\""
-              },
-              {
-                "value": "\"RowOnly\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the selection behavior.\n\n**Note:** Available since [v2.11](https://github.com/UI5/webcomponents/releases/tag/v2.11) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"RowSelector\""
-          }
-        },
-        "headerSelector": {
-          "type": {
-            "name": "enum",
-            "raw": "TableSelectionMultiHeaderSelector | \"SelectAll\" | \"ClearAll\"",
-            "value": [
-              {
-                "value": "\"SelectAll\"",
-                "description": "Renders a checkbox in the table header row that toggles the selection of all rows."
-              },
-              {
-                "value": "\"ClearAll\"",
-                "description": "Renders an icon in the table header row that removes the selection of all rows."
-              },
-              {
-                "value": "\"SelectAll\""
-              },
-              {
-                "value": "\"ClearAll\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the selector of the header row.\n\n**Note:** Available since [v2.12](https://github.com/UI5/webcomponents/releases/tag/v2.12) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"SelectAll\""
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `row-key` values of selected rows, with each value separated by a space."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableSelectionMultiDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "getRowByKey",
-          "description": "Returns the table row instance for the given row key.",
-          "params": [
-            {
-              "name": "rowKey",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "TableRow | undefined"
-          }
-        },
-        {
-          "name": "getSelectedAsSet",
-          "description": "Returns the `selected` property as a set of unique `row-key` values.",
-          "params": [],
-          "returns": {
-            "type": "Set<string>"
-          }
-        },
-        {
-          "name": "getSelectedRows",
-          "description": "Returns an array of the selected rows.",
-          "params": [],
-          "returns": {
-            "type": "Array<TableRow>"
-          }
-        },
-        {
-          "name": "setSelectedAsSet",
-          "description": "Sets the `selected` property using the provided set of unique `row-key` values.",
-          "params": [
-            {
-              "name": "selectedSet",
-              "type": {
-                "name": "Set<string>"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "void"
-          }
-        }
-      ]
-    },
-    "TableSelectionSingle": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableSelectionSingle` component is used inside the `Table` to add single selection capabilities to the `Table`.\nSince selection is key-based, each `TableRow` must define a unique `row-key` property.\n\n### Usage\n\nThe `TableSelectionSingle` component is a feature designed exclusively for use within the `Table` component.\nIt must be placed inside the `features` slot of `Table`.\nThis component is not intended for standalone use.\n\n```html\n<Table>\n\t<TableSelectionSingle slot=\"features\" selected=\"Row1\"></TableSelectionSingle>\n</Table>\n```\n\n\n\n__Note:__ This is a UI5 Web Component! [TableSelectionSingle UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableSelectionSingle) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableSelectionSingleDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the selection is changed by user interaction.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "behavior": {
-          "type": {
-            "name": "enum",
-            "raw": "TableSelectionBehavior | \"RowSelector\" | \"RowOnly\"",
-            "value": [
-              {
-                "value": "\"RowSelector\"",
-                "description": "Rows can only be selected by using the row selector column."
-              },
-              {
-                "value": "\"RowOnly\"",
-                "description": "Rows can only be selected by clicking directly on the row, as the row selector column is hidden.\n\n**Note:** In this mode, the `row-click` event of the `ui5-table` component is not fired."
-              },
-              {
-                "value": "\"RowSelector\""
-              },
-              {
-                "value": "\"RowOnly\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the selection behavior.\n\n**Note:** Available since [v2.11](https://github.com/UI5/webcomponents/releases/tag/v2.11) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"RowSelector\""
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `row-key` value of the selected row."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableSelectionSingleDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "getRowByKey",
-          "description": "Returns the table row instance for the given row key.",
-          "params": [
-            {
-              "name": "rowKey",
-              "type": {
-                "name": "string"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "TableRow | undefined"
-          }
-        },
-        {
-          "name": "getSelectedRow",
-          "description": "Returns the selected row.",
-          "params": [],
-          "returns": {
-            "type": "TableRow | undefined"
-          }
-        }
-      ]
-    },
-    "TableVirtualizer": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TableVirtualizer` component is used inside the `Table` to virtualize the table rows, if the `overflowMode` property of the table is set to 'Scroll'.\nIt is responsible for rendering only the rows that are visible in the viewport and updating them on scroll.\nThis allows large numbers of rows to exist, but maintain high performance by only paying the cost for those that are currently visible.\n\n**Note:** The maximum number of virtualized rows is limited by browser constraints, specifically the maximum supported height for a DOM element.\n\n\n\n__Note:__ This is a UI5 Web Component! [TableVirtualizer UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TableVirtualizer) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onRangeChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TableVirtualizerDomRef, RangeChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the virtualizer is changed by user interaction e.g. on scrolling.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "first",
-                "type": "number",
-                "description": "The 0-based index of the first children currently rendered"
-              },
-              {
-                "name": "last",
-                "type": "number",
-                "description": "The 0-based index of the last children currently rendered"
-              }
-            ],
-            "cancelable": false,
-            "bubbles": false
-          }
-        },
-        "extraRows": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the count of extra rows to be rendered at the top and bottom of the table.\n\n**Note:** This property is experimental and may be changed or deleted in the future.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "rowCount": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the total count of rows in the table.\n\n**Note:** For virtualization to work properly, this property is mandatory.",
-          "defaultValue": {
-            "value": "100"
-          }
-        },
-        "rowHeight": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the height of the rows in the table.\n\n**Note:** For virtualization to work properly, this property is mandatory.",
-          "defaultValue": {
-            "value": "45"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TableVirtualizerDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "reset",
-          "description": "Resets the virtualizer to its initial state and triggers the `range-change` event.",
-          "params": [],
-          "returns": {
-            "type": "void"
-          }
-        }
-      ]
-    },
-    "Tag": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Tag` is a component which serves\nthe purpose to attract the user attention to some piece\nof information (state, quantity, condition, etc.).\nIt can contain icon and text information, and its design can be chosen from specific design types.\n\n### Usage Guidelines\n\n- If the text is longer than the width of the component, it can wrap, or it can show ellipsis, depending on the `wrappingType` property.\n- Colors can be semantic or not semantic.\n\n\n\n__Note:__ This is a UI5 Web Component! [Tag UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Tag) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "icon": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed in the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TagDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on an interactive tag.\n\n**Note:** The event will be fired if the `interactive` property is `true`\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "colorScheme": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the color scheme of the component.\nThere are 10 predefined schemes.\nTo use one you can set a number from `\"1\"` to `\"10\"`. The `colorScheme` `\"1\"` will be set by default.",
-          "defaultValue": {
-            "value": "\"1\""
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "TagDesign | \"Set1\" | \"Set2\" | \"Neutral\" | \"Information\" | \"Positive\" | \"Negative\" | \"Critical\"",
-            "value": [
-              {
-                "value": "\"Set1\"",
-                "description": "Set1 of generic indication colors that are intended for industry-specific use cases"
-              },
-              {
-                "value": "\"Set2\"",
-                "description": "Set2 of generic indication colors that are intended for industry-specific use cases"
-              },
-              {
-                "value": "\"Neutral\"",
-                "description": "Neutral design"
-              },
-              {
-                "value": "\"Information\"",
-                "description": "Information design"
-              },
-              {
-                "value": "\"Positive\"",
-                "description": "Positive design"
-              },
-              {
-                "value": "\"Negative\"",
-                "description": "Negative design"
-              },
-              {
-                "value": "\"Critical\"",
-                "description": "Critical design"
-              },
-              {
-                "value": "\"Set1\""
-              },
-              {
-                "value": "\"Set2\""
-              },
-              {
-                "value": "\"Neutral\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Critical\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the design type of the component.\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Neutral\""
-          }
-        },
-        "hideStateIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the default state icon is shown.\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "interactive": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the component is interactive (focusable and pressable).\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "size": {
-          "type": {
-            "name": "enum",
-            "raw": "TagSize | \"S\" | \"L\"",
-            "value": [
-              {
-                "value": "\"S\"",
-                "description": "Small size of the tag"
-              },
-              {
-                "value": "\"L\"",
-                "description": "Large size of the tag"
-              },
-              {
-                "value": "\"S\""
-              },
-              {
-                "value": "\"L\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines predefined size of the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"S\""
-          }
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "WrappingType | \"None\" | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines how the text of a component will be displayed when there is not enough space.\n\n**Note:** For option \"Normal\" the text will wrap and the\nwords will not be broken based on hyphenation.\n\n**Note:** Available since [v1.22.0](https://github.com/UI5/webcomponents/releases/tag/v1.22.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Normal\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TagDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "root",
-          "description": "Used to style the root element."
-        }
-      ]
-    },
-    "Text": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Text` component displays text that can be used in any content area of an application.\n\n### Usage\n\n- Use the `Text` if you want to display text inside a form, table, or any other content area.\n- Do not use the `Text` if you need to reference input type of components (use ui5-label).\n\n### Responsive behavior\n\nThe `Text` component is fully adaptive to all screen sizes.\nBy default, the text will wrap when the space is not enough.\nIn addition, the component supports truncation via the `max-lines` property,\nby defining the number of lines the text should wrap before start truncating.\n\n\n\n__Note:__ This is a UI5 Web Component! [Text UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Text) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "emptyIndicatorMode": {
-          "type": {
-            "name": "enum",
-            "raw": "TextEmptyIndicatorMode | \"Off\" | \"On\"",
-            "value": [
-              {
-                "value": "\"Off\"",
-                "description": "Empty indicator is never rendered."
-              },
-              {
-                "value": "\"On\"",
-                "description": "Empty indicator is rendered always when the component's content is empty."
-              },
-              {
-                "value": "\"Off\""
-              },
-              {
-                "value": "\"On\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Specifies if an empty indicator should be displayed when there is no text.\n\n**Note:** Available since [v2.2.0](https://github.com/UI5/webcomponents/releases/tag/v2.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Off\""
-          }
-        },
-        "maxLines": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the number of lines the text should wrap before it truncates.",
-          "defaultValue": {
-            "value": "Infinity"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TextDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TextArea": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TextArea` component is used to enter multiple rows of text.\n\nWhen empty, it can hold a placeholder similar to a `Input`.\nYou can define the rows of the `TextArea` and also determine specific behavior when handling long texts.\n\n\n\n__Note:__ This is a UI5 Web Component! [TextArea UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TextArea) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed if the component has\n`valueState` of type `Information`, `Critical` or `Negative`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the text has changed and the focus leaves the component.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TextAreaDomRef, TextAreaInputEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the component changes at each keystroke or when\nsomething is pasted.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "escapePressed",
-                "type": "boolean",
-                "description": "Indicates whether the Escape key was pressed, which triggers a revert to the previous value"
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onScroll": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when textarea is scrolled.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSelect": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when some text has been selected.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the textarea.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the textarea."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the user can interact with the component or not.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "growing": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Enables the component to automatically grow and shrink dynamically with its content.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "growingMaxRows": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the maximum number of rows that the component can grow.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "maxlength": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the maximum number of characters that the `value` can have."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint intended to aid the user with data entry when the component has no value."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "rows": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the number of visible text rows for the component.\n\n**Notes:**\n\n- If the `growing` property is enabled, this property defines the minimum rows to be displayed\nin the textarea.\n- The CSS `height` property wins over the `rows` property, if both are set.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "showExceededText": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the characters exceeding the maximum allowed character count are visible\nin the component.\n\nIf set to `false`, the user is not allowed to enter more characters than what is set in the\n`maxlength` property.\nIf set to `true` the characters exceeding the `maxlength` value are selected on\npaste and the counter below the component displays their number.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.\n\n**Note:** If `maxlength` property is set,\nthe component turns into \"Critical\" state once the characters exceeds the limit.\nIn this case, only the \"Negative\" state is considered and can be applied.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TextAreaDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "textarea",
-          "description": "Used to style the native textarea"
-        }
-      ]
-    },
-    "TimePicker": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TimePicker` component provides an input field with assigned clocks which are opened on user action.\nThe `TimePicker` allows users to select a localized time using touch, mouse, or keyboard input.\nIt consists of two parts: the time input field and the clocks.\n\n### Usage\nThe user can enter a time by:\n\n- Using the clocks that are displayed in a popup\n- Typing it in directly in the input field\n\nWhen the user makes an entry and chooses the enter key, the clocks show the corresponding time (hours, minutes and seconds separately).\nWhen the user directly triggers the clocks display, the actual time is displayed.\nFor the `TimePicker`\n\n### Formatting\n\nIf a time is entered by typing it into\nthe input field, it must fit to the used time format.\n\nSupported format options are pattern-based on Unicode LDML Date Format notation.\nFor more information, see [UTS #35: Unicode Locale Data Markup Language](https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table).\n\nFor example, if the `format-pattern` is \"HH:mm:ss\",\na valid value string is \"11:42:35\" and the same is displayed in the input.\n\n### Keyboard handling\n[F4], [Alt]+[Up], [Alt]+[Down] Open/Close picker dialog and move focus to it.\n\nWhen closed:\n\n- [Page Up] - Increments hours by 1. If 12 am is reached, increment hours to 1 pm and vice versa.\n- [Page Down] - Decrements the corresponding field by 1. If 1 pm is reached, decrement hours to 12 am and vice versa.\n- [Shift]+[Page Up] - Increments minutes by 1.\n- [Shift]+[Page Down] - Decrements minutes by 1.\n- [Shift]+[Ctrl]+[Page Up] - Increments seconds by 1.\n- [Shift]+[Ctrl]+[Page Down] - Decrements seconds by 1.\n-\n\nWhen opened:\n\n- [Page Up] - Increments hours by 1. If 12 am is reached, increment hours to 1 pm and vice versa.\n- [Page Down] - Decrements the corresponding field by 1. If 1 pm is reached, decrement hours to 12 am and vice versa.\n- [Shift]+[Page Up] - Increments minutes by 1.\n- [Shift]+[Page Down] - Decrements minutes by 1.\n- [Shift]+[Ctrl]+[Page Up] - Increments seconds by 1.\n- [Shift]+[Ctrl]+[Page Down] - Decrements seconds by 1.\n- [A] or [P] - Selects AM or PM respectively.\n- [0]-[9] - Allows direct time selecting (hours/minutes/seconds).\n- [:] - Allows switching between hours/minutes/seconds clocks. If the last clock is displayed and [:] is pressed, the first clock is beind displayed.\n\n\n\n__Note:__ This is a UI5 Web Component! [TimePicker UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TimePicker) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the `TimePicker`.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the `TimePicker` is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TimePickerDomRef, TimePickerChangeInputEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by clicking the \"OK\" button or\nwhen the text in the input field has changed and the focus leaves the input field.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in correct format pattern and in valid range."
-              },
-              {
-                "name": "value",
-                "type": "string",
-                "description": "The submitted value."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TimePickerDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the value-help dialog of the component is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TimePickerDomRef, TimePickerChangeInputEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the `TimePicker` is changed at each key stroke.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "valid",
-                "type": "boolean",
-                "description": "Indicator if the value is in correct format pattern and in valid range."
-              },
-              {
-                "name": "value",
-                "type": "string",
-                "description": "The current value."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TimePickerDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the value-help dialog of the component is opened.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.14.0](https://github.com/UI5/webcomponents/releases/tag/v2.14.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the aria-label attribute for the component.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id (or many ids) of the elements that label the component.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the disabled state of the comonent.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "formatPattern": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the format, displayed in the input field.\n\nExample:\nHH:mm:ss -> 11:42:35\nhh:mm:ss a -> 2:23:15 PM\nmm:ss -> 12:04 (only minutes and seconds)"
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**."
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the open or closed state of the popover.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint, intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** When no placeholder is set, the format pattern is displayed as a placeholder.\nPassing an empty string as the value of this property will make the component appear empty - without placeholder or format pattern."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the readonly state of the comonent.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a formatted time value."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TimePickerDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "formatValue",
-          "description": "Currently selected time represented as JavaScript Date instance / readonly dateValue: Date | null; /** Formats a Java Script date object into a string representing a locale date and time according to the `formatPattern` property of the TimePicker instance",
-          "params": [
-            {
-              "name": "date",
-              "type": {
-                "name": "Date"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "string"
-          }
-        },
-        {
-          "name": "isValid",
-          "description": "Checks if a value is valid against the current `formatPattern` value. **Note:** an empty string is considered as valid value.",
-          "params": [
-            {
-              "name": "value",
-              "type": {
-                "name": "string | undefined"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "boolean"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "input",
-          "description": "Used to style the input element. This part is forwarded to the underlying ui5-input element."
-        }
-      ]
-    },
-    "Timeline": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Timeline` component shows entries (such as objects, events, or posts) in chronological order.\nA common use case is to provide information about changes to an object, or events related to an object.\nThese entries can be generated by the system (for example, value XY changed from A to B), or added manually.\nThere are two distinct variants of the timeline: basic and social. The basic timeline is read-only,\nwhile the social timeline offers a high level of interaction and collaboration, and is integrated within SAP Jam.\n\n__Note:__ This is a UI5 Web Component! [Timeline UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/Timeline) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Determines the content of the `Timeline`.\n\n__Supported Node Type/s:__ `Array<ITimelineItem>`"
-        },
-        "onLoadMore": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TimelineDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user presses the `More` button or scrolls to the Timeline's end.\n\n**Note:** The event will be fired if `growing` is set to `Button` or `Scroll`.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents-fiori**."
-        },
-        "growing": {
-          "type": {
-            "name": "enum",
-            "raw": "TimelineGrowingMode | \"Button\" | \"Scroll\" | \"None\"",
-            "value": [
-              {
-                "value": "\"Button\"",
-                "description": "Event `load-more` is fired\nupon pressing a \"More\" button at the end."
-              },
-              {
-                "value": "\"Scroll\"",
-                "description": "Event `load-more` is fired upon scroll."
-              },
-              {
-                "value": "\"None\"",
-                "description": "The growing feature is not enabled."
-              },
-              {
-                "value": "\"Button\""
-              },
-              {
-                "value": "\"Scroll\""
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines whether the Timeline will have growing capability either by pressing a \"More\" button,\nor via user scroll. In both cases a `load-more` event is fired.\n\nAvailable options:\n\n`Button` - Displays a button at the end of the Timeline, which when pressed triggers the `load-more` event.\n\n`Scroll` -Triggers the `load-more` event when the user scrolls to the end of the Timeline.\n\n`None` (default) - The growing functionality is off.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "layout": {
-          "type": {
-            "name": "enum",
-            "raw": "TimelineLayout | \"Vertical\" | \"Horizontal\"",
-            "value": [
-              {
-                "value": "\"Vertical\"",
-                "description": "Vertical layout\nDefault type"
-              },
-              {
-                "value": "\"Horizontal\"",
-                "description": "Horizontal layout"
-              },
-              {
-                "value": "\"Vertical\""
-              },
-              {
-                "value": "\"Horizontal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the items orientation.",
-          "defaultValue": {
-            "value": "\"Vertical\""
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the component should display a loading indicator over the Timeline.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the loading indicator will show up for this component.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TimelineDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TimelineGroupItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "An entry posted on the timeline.\nIt is intented to represent a group of `<TimelineItem>`s.\n\n**Note**: Please do not use empty groups in order to preserve the intended design.\n\n__Note:__ This is a UI5 Web Component! [TimelineGroupItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/TimelineGroupItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Determines the content of the `TimelineGroupItem`.\n\n__Supported Node Type/s:__ `Array<ITimelineItem>`"
-        },
-        "onToggle": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TimelineGroupItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the group item is expanded or collapsed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "collapsed": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines if the group is collapsed or expanded.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "groupName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the button that expands and collapses the group."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TimelineGroupItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TimelineItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "An entry posted on the timeline.\n\n__Note:__ This is a UI5 Web Component! [TimelineItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/TimelineItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the `TimelineItem`.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "onNameClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TimelineItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the item name is pressed either with a\nclick/tap or by using the Enter or Space key.\n\n**Note:** The event will not be fired if the `name-clickable`\nattribute is not set.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed as graphical element within the `TimelineItem`.\nSAP-icons font provides numerous options.\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the name of the item, displayed before the `title-text`."
-        },
-        "nameClickable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the `name` is clickable.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "state": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the state of the icon displayed in the `TimelineItem`.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "subtitleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the subtitle text of the component."
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the title text of the component."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TimelineItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Title": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Title` component is used to display titles inside a page.\nIt is a simple, large-sized text with explicit header/title semantics.\n\n\n\n__Note:__ This is a UI5 Web Component! [Title UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Title) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\nThis component supports nesting a `Link` component inside.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "level": {
-          "type": {
-            "name": "enum",
-            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
-            "value": [
-              {
-                "value": "\"H1\"",
-                "description": "Renders `h1` tag."
-              },
-              {
-                "value": "\"H2\"",
-                "description": "Renders `h2` tag."
-              },
-              {
-                "value": "\"H3\"",
-                "description": "Renders `h3` tag."
-              },
-              {
-                "value": "\"H4\"",
-                "description": "Renders `h4` tag."
-              },
-              {
-                "value": "\"H5\"",
-                "description": "Renders `h5` tag."
-              },
-              {
-                "value": "\"H6\"",
-                "description": "Renders `h6` tag."
-              },
-              {
-                "value": "\"H1\""
-              },
-              {
-                "value": "\"H2\""
-              },
-              {
-                "value": "\"H3\""
-              },
-              {
-                "value": "\"H4\""
-              },
-              {
-                "value": "\"H5\""
-              },
-              {
-                "value": "\"H6\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component level.\nAvailable options are: `\"H6\"` to `\"H1\"`.\nThis property does not influence the style of the component.\nUse the property `size` for this purpose instead.",
-          "defaultValue": {
-            "value": "\"H2\""
-          }
-        },
-        "size": {
-          "type": {
-            "name": "enum",
-            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
-            "value": [
-              {
-                "value": "\"H1\"",
-                "description": "Renders `h1` tag."
-              },
-              {
-                "value": "\"H2\"",
-                "description": "Renders `h2` tag."
-              },
-              {
-                "value": "\"H3\"",
-                "description": "Renders `h3` tag."
-              },
-              {
-                "value": "\"H4\"",
-                "description": "Renders `h4` tag."
-              },
-              {
-                "value": "\"H5\"",
-                "description": "Renders `h5` tag."
-              },
-              {
-                "value": "\"H6\"",
-                "description": "Renders `h6` tag."
-              },
-              {
-                "value": "\"H1\""
-              },
-              {
-                "value": "\"H2\""
-              },
-              {
-                "value": "\"H3\""
-              },
-              {
-                "value": "\"H4\""
-              },
-              {
-                "value": "\"H5\""
-              },
-              {
-                "value": "\"H6\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the visual appearance of the title.\nAvailable options are: `\"H6\"` to `\"H1\"`.",
-          "defaultValue": {
-            "value": "\"H5\""
-          }
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "WrappingType | \"None\" | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines how the text of a component will be displayed when there is not enough space.\n\n**Note:** for option \"Normal\" the text will wrap and the words will not be broken based on hyphenation.",
-          "defaultValue": {
-            "value": "\"Normal\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TitleDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Toast": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Toast` is a small, non-disruptive popup for success or information messages that\ndisappears automatically after a few seconds.\n\n### Usage\n\n#### When to use:\n\n- You want to display a short success or information message.\n- You do not want to interrupt users while they are performing an action.\n- You want to confirm a successful action.\n\n#### When not to use:\n\n- You want to display error or warning message.\n- You want to interrupt users while they are performing an action.\n- You want to make sure that users read the message before they leave the page.\n- You want users to be able to copy some part of the message text.\n\n\n\n__Note:__ This is a UI5 Web Component! [Toast UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Toast) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ToastDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component is auto closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "duration": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the duration in milliseconds for which component\nremains on the screen before it's automatically closed.\n\n**Note:** The minimum supported value is `500` ms\nand even if a lower value is set, the duration would remain `500` ms.",
-          "defaultValue": {
-            "value": "3000"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the component is open (visible).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placement": {
-          "type": {
-            "name": "enum",
-            "raw": "ToastPlacement | \"TopStart\" | \"TopCenter\" | \"TopEnd\" | \"MiddleStart\" | \"MiddleCenter\" | \"MiddleEnd\" | \"BottomStart\" | \"BottomCenter\" | \"BottomEnd\"",
-            "value": [
-              {
-                "value": "\"TopStart\"",
-                "description": "Toast is placed at the `TopStart` position of its container."
-              },
-              {
-                "value": "\"TopCenter\"",
-                "description": "Toast is placed at the `TopCenter` position of its container."
-              },
-              {
-                "value": "\"TopEnd\"",
-                "description": "Toast is placed at the `TopEnd` position of its container."
-              },
-              {
-                "value": "\"MiddleStart\"",
-                "description": "Toast is placed at the `MiddleStart` position of its container."
-              },
-              {
-                "value": "\"MiddleCenter\"",
-                "description": "Toast is placed at the `MiddleCenter` position of its container."
-              },
-              {
-                "value": "\"MiddleEnd\"",
-                "description": "Toast is placed at the `MiddleEnd` position of its container."
-              },
-              {
-                "value": "\"BottomStart\"",
-                "description": "Toast is placed at the `BottomStart` position of its container."
-              },
-              {
-                "value": "\"BottomCenter\"",
-                "description": "Toast is placed at the `BottomCenter` position of its container.\nDefault placement (no selection)"
-              },
-              {
-                "value": "\"BottomEnd\"",
-                "description": "Toast is placed at the `BottomEnd` position of its container."
-              },
-              {
-                "value": "\"TopStart\""
-              },
-              {
-                "value": "\"TopCenter\""
-              },
-              {
-                "value": "\"TopEnd\""
-              },
-              {
-                "value": "\"MiddleStart\""
-              },
-              {
-                "value": "\"MiddleCenter\""
-              },
-              {
-                "value": "\"MiddleEnd\""
-              },
-              {
-                "value": "\"BottomStart\""
-              },
-              {
-                "value": "\"BottomCenter\""
-              },
-              {
-                "value": "\"BottomEnd\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the placement of the component.",
-          "defaultValue": {
-            "value": "\"BottomCenter\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ToastDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ToggleButton": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ToggleButton` component is an enhanced `Button`\nthat can be toggled between pressed and normal states.\nUsers can use the `ToggleButton` as a switch to turn a setting on or off.\nIt can also be used to represent an independent choice similar to a check box.\n\nClicking or tapping on a `ToggleButton` changes its state to `pressed`. The button returns to\nits initial state when the user clicks or taps on it again.\nBy applying additional custom CSS-styling classes, apps can give a different style to any `ToggleButton`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ToggleButton UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToggleButton) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "badge": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Adds a badge to the button.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"badge\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<ButtonBadge>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ToggleButtonDomRef, ButtonClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is activated either with a mouse/tap or by using the Enter or Space key.\n\n**Note:** The event will not be fired if the `disabled` property is set to `true`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "altKey",
-                "type": "boolean",
-                "description": "Returns whether the \"ALT\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "ctrlKey",
-                "type": "boolean",
-                "description": "Returns whether the \"CTRL\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "metaKey",
-                "type": "boolean",
-                "description": "Returns whether the \"META\" key was pressed when the event was triggered."
-              },
-              {
-                "name": "originalEvent",
-                "type": "Event",
-                "description": "Returns original event that comes from user's **click** interaction"
-              },
-              {
-                "name": "shiftKey",
-                "type": "boolean",
-                "description": "Returns whether the \"SHIFT\" key was pressed when the event was triggered."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ButtonAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls, is currently expanded or collapsed.\nAccepts the following string values: `true` or `false`\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n- **ariaLabel**: Defines the accessible ARIA name of the component.\nAccepts any string value.\n\n - **ariaKeyShortcuts**: Defines keyboard shortcuts that activate or give focus to the button.\n\n- **controls**: Identifies the element (or elements) whose contents or presence are controlled by the button element.\nAccepts a lowercase string value.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**."
-        },
-        "accessibleRole": {
-          "type": {
-            "name": "enum",
-            "raw": "ButtonAccessibleRole | \"Button\" | \"Link\"",
-            "value": [
-              {
-                "value": "\"Button\"",
-                "description": "Represents Default (button) ARIA role."
-              },
-              {
-                "value": "\"Link\"",
-                "description": "Represents the ARIA role \"link\"."
-              },
-              {
-                "value": "\"Button\""
-              },
-              {
-                "value": "\"Link\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Describes the accessibility role of the button.\n\n**Note:** Use <code>ButtonAccessibleRole.Link</code> role only with a press handler, which performs a navigation. In all other scenarios the default button semantics are recommended.\n\n**Note:** Available since [v1.23](https://github.com/UI5/webcomponents/releases/tag/v1.23) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Button\""
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "ButtonDesign | \"Default\" | \"Positive\" | \"Negative\" | \"Transparent\" | \"Emphasized\" | \"Attention\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "default type (no special styling)"
-              },
-              {
-                "value": "\"Positive\"",
-                "description": "accept type (green button)"
-              },
-              {
-                "value": "\"Negative\"",
-                "description": "reject style (red button)"
-              },
-              {
-                "value": "\"Transparent\"",
-                "description": "transparent type"
-              },
-              {
-                "value": "\"Emphasized\"",
-                "description": "emphasized type"
-              },
-              {
-                "value": "\"Attention\"",
-                "description": "attention type"
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Transparent\""
-              },
-              {
-                "value": "\"Emphasized\""
-              },
-              {
-                "value": "\"Attention\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component design.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "endIcon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon, displayed as graphical element within the component after the button text.\n\n**Note:** It is highly recommended to use `endIcon` property only together with `icon` and/or `text` properties.\nUsage of `endIcon` only should be avoided.\n\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon, displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the button shows a loading indicator.\n\n**Note:** If set to `true`, a busy indicator component will be displayed on the related button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Specifies the delay in milliseconds before the loading indicator appears within the associated button.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "pressed": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the component is displayed as pressed.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "submits": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "When set to `true`, the component will\nautomatically submit the nearest HTML form element on `press`.\n\n**Note:** This property is only applicable within the context of an HTML Form element.`\n@deprecated Set the \"type\" property to \"Submit\" to achieve the same result. The \"submits\" property is ignored if \"type\" is set to any value other than \"Button\".",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\n**Note:** A tooltip attribute should be provided for icon-only buttons, in order to represent their exact meaning/function.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents**."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Button\" | ButtonType | \"Submit\" | \"Reset\"",
-            "value": [
-              {
-                "value": "\"Button\""
-              },
-              {
-                "value": "\"Button\"",
-                "description": "The button does not do anything special when inside a form"
-              },
-              {
-                "value": "\"Submit\"",
-                "description": "The button acts as a submit button (submits a form)"
-              },
-              {
-                "value": "\"Reset\"",
-                "description": "The button acts as a reset button (resets a form)"
-              },
-              {
-                "value": "\"Submit\""
-              },
-              {
-                "value": "\"Reset\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines whether the button has special form-related functionality.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Button\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ToggleButtonDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "button",
-          "description": "Used to style the native button element"
-        },
-        {
-          "name": "endIcon",
-          "description": "Used to style the end icon in the native button element"
-        },
-        {
-          "name": "icon",
-          "description": "Used to style the icon in the native button element"
-        }
-      ]
-    },
-    "Token": {
-      "package": "@ui5/webcomponents-react",
-      "description": "Tokens are small items of information (similar to tags) that mainly serve to visualize previously selected items.\n\n\n\n__Note:__ This is a UI5 Web Component! [Token UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Token) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "closeIcon": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the close icon for the token. If nothing is provided to this slot, the default close icon will be used.\nAccepts `Icon`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"closeIcon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is selected or not.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the token."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TokenDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Tokenizer": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A `Tokenizer` is an invisible container for `Token`s that supports keyboard navigation and token selection.\n\nThe `Tokenizer` consists of two parts:\n- Tokens - displays the available tokens.\n- N-more indicator - contains the number of the remaining tokens that cannot be displayed due to the limited space.\n\n### Keyboard Handling\n\n#### Basic Navigation\nThe `Tokenizer` provides advanced keyboard handling.\nWhen a token is focused the user can use the following keyboard\nshortcuts in order to perform a navigation:\n\n- [Left] or [Right] / [Up] or [Down] - Navigates left and right through the tokens.\n- [Home] - Navigates to the first token.\n- [End] - Navigates to the last token.\n\nThe user can use the following keyboard shortcuts to perform actions (such as select, delete):\n\n- [Space] - Selects a token.\n- [Backspace] / [Delete] - Deletes a token.\n**Note:** The deletion of a token is handled by the application with the use of the `token-delete` event.\n\n\n\n__Note:__ This is a UI5 Web Component! [Tokenizer UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Tokenizer) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the tokens to be displayed.\n\n__Supported Node Type/s:__ `Array<Token>`"
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TokenizerDomRef, TokenizerSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when token selection is changed by user interaction\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "tokens",
-                "type": "Array<Token>",
-                "description": "An array of the selected items."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onTokenDelete": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TokenizerDomRef, TokenizerTokenDeleteEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when tokens are being deleted (delete icon, delete or backspace is pressed)\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "tokens",
-                "type": "Array",
-                "description": "An array containing the deleted tokens."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "multiLine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether tokens are displayed on multiple lines.\n\n**Note:** The `multiLine` property is in an experimental state and is a subject to change.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element.\n**Note:** When the component is used inside a form element,\nthe value is sent as the first element in the form data, even if it's empty."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showClearAll": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether \"Clear All\" button is present. Ensure `multiLine` is enabled, otherwise `showClearAll` will have no effect.\n\n**Note:** The `showClearAll` property is in an experimental state and is a subject to change.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TokenizerDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Toolbar": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Toolbar` component is used to create a horizontal layout with items.\nThe items can be overflowing in a popover, when the space is not enough to show all of them.\n\n### Keyboard Handling\nThe `Toolbar` provides advanced keyboard handling.\n\n- The control is not interactive, but can contain of interactive elements\n- [Tab] - iterates through elements\n\n\n\n__Note:__ This is a UI5 Web Component! [Toolbar UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Toolbar) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the component.\n\n**Note:** Currently only `ToolbarButton`, `ToolbarSelect`, `ToolbarSeparator` and `ToolbarSpacer` are allowed here.\n\n__Supported Node Type/s:__ `Array<ToolbarItemBase>`"
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the input."
-        },
-        "alignContent": {
-          "type": {
-            "name": "enum",
-            "raw": "ToolbarAlign | \"Start\" | \"End\"",
-            "value": [
-              {
-                "value": "\"Start\"",
-                "description": "Toolbar items are situated at the `start` of the Toolbar"
-              },
-              {
-                "value": "\"End\"",
-                "description": "Toolbar items are situated at the `end` of the Toolbar"
-              },
-              {
-                "value": "\"Start\""
-              },
-              {
-                "value": "\"End\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Indicated the direction in which the Toolbar items will be aligned.",
-          "defaultValue": {
-            "value": "\"End\""
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "ToolbarDesign | \"Solid\" | \"Transparent\"",
-            "value": [
-              {
-                "value": "\"Solid\"",
-                "description": "The toolbar and its content will be displayed with solid background."
-              },
-              {
-                "value": "\"Transparent\"",
-                "description": "The toolbar and its content will be displayed with transparent background."
-              },
-              {
-                "value": "\"Solid\""
-              },
-              {
-                "value": "\"Transparent\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the toolbar design.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"Solid\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ToolbarDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "isOverflowOpen",
-          "description": "Returns if the overflow popup is open.",
-          "params": [],
-          "returns": {
-            "type": "boolean"
-          }
-        }
-      ]
-    },
-    "ToolbarButton": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ToolbarButton` represents an abstract action,\nused in the `Toolbar`.\n\n\n\n__Note:__ This is a UI5 Web Component! [ToolbarButton UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarButton) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ToolbarButtonDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is activated either with a\nmouse/tap or by using the Enter or Space key.\n\n**Note:** The event will not be fired if the `disabled`\nproperty is set to `true`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ButtonAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\n\nThe following fields are supported:\n\n- **expanded**: Indicates whether the button, or another grouping element it controls, is currently expanded or collapsed.\nAccepts the following string values: `true` or `false`\n\n- **hasPopup**: Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the button.\nAccepts the following string values: `dialog`, `grid`, `listbox`, `menu` or `tree`.\n\n- **controls**: Identifies the element (or elements) whose contents or presence are controlled by the button element.\nAccepts a lowercase string value.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the component."
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "ButtonDesign | \"Default\" | \"Positive\" | \"Negative\" | \"Transparent\" | \"Emphasized\" | \"Attention\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "default type (no special styling)"
-              },
-              {
-                "value": "\"Positive\"",
-                "description": "accept type (green button)"
-              },
-              {
-                "value": "\"Negative\"",
-                "description": "reject style (red button)"
-              },
-              {
-                "value": "\"Transparent\"",
-                "description": "transparent type"
-              },
-              {
-                "value": "\"Emphasized\"",
-                "description": "emphasized type"
-              },
-              {
-                "value": "\"Attention\"",
-                "description": "attention type"
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Transparent\""
-              },
-              {
-                "value": "\"Emphasized\""
-              },
-              {
-                "value": "\"Attention\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the action design.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the action is disabled.\n\n**Note:** a disabled action can't be pressed or focused, and it is not in the tab chain.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "endIcon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon, displayed as graphical element within the component after the button text.\n\n**Note:** It is highly recommended to use `endIcon` property only together with `icon` and/or `text` properties.\nUsage of `endIcon` only should be avoided.\n\nThe SAP-icons font provides numerous options.\n\nExample:\nSee all the available icons within the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `icon` source URI.\n\n**Note:** SAP-icons font provides numerous buil-in icons. To find all the available icons, see the\n[Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "overflowPriority": {
-          "type": {
-            "name": "enum",
-            "raw": "\"Default\" | ToolbarItemOverflowBehavior | \"NeverOverflow\" | \"AlwaysOverflow\"",
-            "value": [
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Default\"",
-                "description": "The item is presented inside the toolbar and goes in the popover, when there is not enough space."
-              },
-              {
-                "value": "\"NeverOverflow\"",
-                "description": "When set, the item will never go to the overflow popover."
-              },
-              {
-                "value": "\"AlwaysOverflow\"",
-                "description": "When set, the item will be always part of the overflow part of ui5-toolbar."
-              },
-              {
-                "value": "\"NeverOverflow\""
-              },
-              {
-                "value": "\"AlwaysOverflow\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Property used to define the access of the item to the overflow Popover. If \"NeverOverflow\" option is set,\nthe item never goes in the Popover, if \"AlwaysOverflow\" - it never comes out of it.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "preventOverflowClosing": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the toolbar overflow popup should close upon interaction with the item.\nIt will close by default.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showOverflowText": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the button text should only be displayed in the overflow popover.\n\nWhen set to `true`, the button appears as icon-only in the main toolbar,\nbut shows both icon and text when moved to the overflow popover.\n\n**Note:** This property only takes effect when the `text` property is also set.\n\n**Note:** Available since [v2.17.0](https://github.com/UI5/webcomponents/releases/tag/v2.17.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Button text"
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\n**Note:** A tooltip attribute should be provided for icon-only buttons, in order to represent their exact meaning/function."
-        },
-        "width": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the width of the button.\n\n**Note:** all CSS sizes are supported - 'percentage', 'px', 'rem', 'auto', etc."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ToolbarButtonDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ToolbarItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ToolbarItem` is a wrapper component used to integrate UI5 Web Components into the `Toolbar`.\nIt renders within the toolbar's shadow DOM and manages the lifecycle\nand overflow behavior of its child component.\n\n### Structure\nThe toolbar item wraps a single UI5 Web Component (such as CheckBox, Title, etc.) and handles:\n- Overflow management (determining if the item should be displayed in the main toolbar or overflow popover)\n- Automatic popover closing on interaction\n- CSS custom state exposure for styling based on overflow state\n\n### Usage\nThe `ToolbarItem` is typically used implicitly when adding components to a toolbar,\nbut specialized wrappers like `ToolbarButton` provide\ncomponent-specific functionality and should be preferred when available.\n\n__Note:__ This is a UI5 Web Component! [ToolbarItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Wrapped component slot.\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IToolbarItemContent>`"
-        },
-        "overflowPriority": {
-          "type": {
-            "name": "enum",
-            "raw": "ToolbarItemOverflowBehavior | \"Default\" | \"NeverOverflow\" | \"AlwaysOverflow\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "The item is presented inside the toolbar and goes in the popover, when there is not enough space."
-              },
-              {
-                "value": "\"NeverOverflow\"",
-                "description": "When set, the item will never go to the overflow popover."
-              },
-              {
-                "value": "\"AlwaysOverflow\"",
-                "description": "When set, the item will be always part of the overflow part of ui5-toolbar."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"NeverOverflow\""
-              },
-              {
-                "value": "\"AlwaysOverflow\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Property used to define the access of the item to the overflow Popover. If \"NeverOverflow\" option is set,\nthe item never goes in the Popover, if \"AlwaysOverflow\" - it never comes out of it.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "preventOverflowClosing": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the toolbar overflow popup should close upon interaction with the item.\nIt will close by default.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ToolbarItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ToolbarSelect": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ToolbarSelect` component is used to create a toolbar drop-down list.\nThe items inside the `ToolbarSelect` define the available options by using the `ToolbarSelectOption` component.\n\n\n\n`import \"@ui5/webcomponents/dist/ToolbarSelectOption.js\";` (comes with `ToolbarSelect`)\n\n__Note:__ This is a UI5 Web Component! [ToolbarSelect UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarSelect) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the component options.\n\n**Note:** Only one selected option is allowed.\nIf more than one option is defined as selected, the last one would be considered as the selected one.\n\n**Note:** Use the `ToolbarSelectOption` component to define the desired options.\n\n__Supported Node Type/s:__ `Array<ToolbarSelectOption>`"
-        },
-        "label": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the HTML element that will be displayed in the component input part,\nrepresenting the selected option.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"label\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ToolbarSelectDomRef, ToolbarSelectChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the selected option changes.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "selectedOption",
-                "type": "HTMLElement",
-                "description": "the selected option."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ToolbarSelectDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component's dropdown menu closes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ToolbarSelectDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the component's dropdown menu opens.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the select."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "overflowPriority": {
-          "type": {
-            "name": "enum",
-            "raw": "ToolbarItemOverflowBehavior | \"Default\" | \"NeverOverflow\" | \"AlwaysOverflow\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "The item is presented inside the toolbar and goes in the popover, when there is not enough space."
-              },
-              {
-                "value": "\"NeverOverflow\"",
-                "description": "When set, the item will never go to the overflow popover."
-              },
-              {
-                "value": "\"AlwaysOverflow\"",
-                "description": "When set, the item will be always part of the overflow part of ui5-toolbar."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"NeverOverflow\""
-              },
-              {
-                "value": "\"AlwaysOverflow\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Property used to define the access of the item to the overflow Popover. If \"NeverOverflow\" option is set,\nthe item never goes in the Popover, if \"AlwaysOverflow\" - it never comes out of it.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "preventOverflowClosing": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the toolbar overflow popup should close upon interaction with the item.\nIt will close by default.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component:\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents**."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "width": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the width of the select.\n\n**Note:** all CSS sizes are supported - 'percentage', 'px', 'rem', 'auto', etc."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ToolbarSelectDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ToolbarSelectOption": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ToolbarSelectOption` component defines the content of an option in the `ToolbarSelect`.\n\n__Note:__ This is a UI5 Web Component! [ToolbarSelectOption UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarSelectOption) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the text of the component.\n\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that you only use text in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ToolbarSelectOptionDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ToolbarSeparator": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ToolbarSeparator` is an element, used for visual separation between two elements.\nIt takes no space in calculating toolbar items width.\n\n__Note:__ This is a UI5 Web Component! [ToolbarSeparator UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarSeparator) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "overflowPriority": {
-          "type": {
-            "name": "enum",
-            "raw": "ToolbarItemOverflowBehavior | \"Default\" | \"NeverOverflow\" | \"AlwaysOverflow\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "The item is presented inside the toolbar and goes in the popover, when there is not enough space."
-              },
-              {
-                "value": "\"NeverOverflow\"",
-                "description": "When set, the item will never go to the overflow popover."
-              },
-              {
-                "value": "\"AlwaysOverflow\"",
-                "description": "When set, the item will be always part of the overflow part of ui5-toolbar."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"NeverOverflow\""
-              },
-              {
-                "value": "\"AlwaysOverflow\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Property used to define the access of the item to the overflow Popover. If \"NeverOverflow\" option is set,\nthe item never goes in the Popover, if \"AlwaysOverflow\" - it never comes out of it.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "preventOverflowClosing": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the toolbar overflow popup should close upon interaction with the item.\nIt will close by default.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ToolbarSeparatorDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ToolbarSpacer": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ToolbarSpacer` is an element, used for taking needed space for toolbar items to take 100% width.\nIt takes no space in calculating toolbar items width.\n\n__Note:__ This is a UI5 Web Component! [ToolbarSpacer UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ToolbarSpacer) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "overflowPriority": {
-          "type": {
-            "name": "enum",
-            "raw": "ToolbarItemOverflowBehavior | \"Default\" | \"NeverOverflow\" | \"AlwaysOverflow\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "The item is presented inside the toolbar and goes in the popover, when there is not enough space."
-              },
-              {
-                "value": "\"NeverOverflow\"",
-                "description": "When set, the item will never go to the overflow popover."
-              },
-              {
-                "value": "\"AlwaysOverflow\"",
-                "description": "When set, the item will be always part of the overflow part of ui5-toolbar."
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"NeverOverflow\""
-              },
-              {
-                "value": "\"AlwaysOverflow\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Property used to define the access of the item to the overflow Popover. If \"NeverOverflow\" option is set,\nthe item never goes in the Popover, if \"AlwaysOverflow\" - it never comes out of it.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "preventOverflowClosing": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the toolbar overflow popup should close upon interaction with the item.\nIt will close by default.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "width": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the width of the spacer.\n\n**Note:** all CSS sizes are supported - 'percentage', 'px', 'rem', 'auto', etc."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ToolbarSpacerDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Tree": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Tree` component provides a tree structure for displaying data in a hierarchy.\n\n### Usage\n\n#### When to use:\n\n- To display hierarchically structured items.\n- To select one or more items out of a set of hierarchically structured items.\n\n#### When not to use:\n\n- To display items not hierarchically structured. In this case, use the List component.\n- To select one item from a very small number of non-hierarchical items. Select or ComboBox might be more appropriate.\n- The hierarchy turns out to have only two levels. In this case, use List with group items.\n\n### Keyboard Handling\n\nThe `Tree` provides advanced keyboard handling.\nThe user can use the following keyboard shortcuts in order to navigate trough the tree:\n\n- [Up] or [Down] - Navigates up and down the tree items that are currently visible.\n- [Right] - Drills down the tree by expanding the tree nodes.\n- [Left] - Goes up the tree and collapses the tree nodes.\n\nThe user can use the following keyboard shortcuts to perform selection,\nwhen the `selectionMode` property is in use:\n\n- [Space] - Selects the currently focused item upon keyup.\n- [Enter]  - Selects the currently focused item upon keydown.\n\n\n\n`import \"@ui5/webcomponents/dist/TreeItem.js\";`\n\n__Note:__ This is a UI5 Web Component! [Tree UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/Tree) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the component. Tree items may have other tree items as children.\n\n**Note:** Use `TreeItem` for the intended design.\n\n__Supported Node Type/s:__ `Array<TreeItemBase>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the component header.\n\n**Note:** When the `header` slot is set, the\n`headerText` property is ignored.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onItemClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeItemEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a tree item is activated.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The clicked item."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onItemDelete": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeItemEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the Delete button of any tree item is pressed.\n\n**Note:** A Delete button is displayed on each item,\nwhen the component `selectionMode` property is set to `Delete`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "the deleted item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onItemMouseout": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeItemEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the mouse cursor leaves the tree item borders.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "the hovered item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onItemMouseover": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeItemEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the mouse cursor enters the tree item borders.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "the hovered item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onItemToggle": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeItemEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a tree item is expanded or collapsed.\n\n**Note:** You can call `preventDefault()` on the event object to suppress the event, if needed.\nThis may be handy for example if you want to dynamically load tree items upon the user expanding a node.\nEven if you prevented the event's default behavior, you can always manually call `toggle()` on a tree item.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "the toggled item."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onMove": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable tree item is moved over a potential drop target during a drag-and-drop operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under the `element` property."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMoveOver": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable tree item is dropped onto a drop target.\n\n**Note:** The `move` event is fired only if there was a preceding `move-over` event with prevented default action.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under the `element` property."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TreeDomRef, TreeSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when selection is changed by user interaction\nin `Single`, `SingleStart`, `SingleEnd` and `Multiple` modes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "previouslySelectedItems",
-                "type": "Array",
-                "description": "An array of the previously selected items."
-              },
-              {
-                "name": "selectedItems",
-                "type": "Array",
-                "description": "An array of the selected items."
-              },
-              {
-                "name": "targetItem",
-                "type": "HTMLElement",
-                "description": "The item triggering the event."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that describe the component.\n\n**Note:** Available since [v2.5.0](https://github.com/UI5/webcomponents/releases/tag/v2.5.0) of **@ui5/webcomponents**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents**."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the IDs of the elements that label the component.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents**."
-        },
-        "footerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the component footer text."
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the component header text.\n\n**Note:** If the `header` slot is set, this property is ignored."
-        },
-        "noDataText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text that is displayed when the component contains no items."
-        },
-        "selectionMode": {
-          "type": {
-            "name": "enum",
-            "raw": "ListSelectionMode | \"None\" | \"Single\" | \"SingleStart\" | \"SingleEnd\" | \"SingleAuto\" | \"Multiple\" | \"Delete\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "Default mode (no selection)."
-              },
-              {
-                "value": "\"Single\"",
-                "description": "Right-positioned single selection mode (only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleStart\"",
-                "description": "Left-positioned single selection mode (only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleEnd\"",
-                "description": "Selected item is highlighted but no selection element is visible\n(only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleAuto\"",
-                "description": "Selected item is highlighted and selection is changed upon arrow navigation\n(only one list item can be selected - this is always the focused item)."
-              },
-              {
-                "value": "\"Multiple\"",
-                "description": "Multi selection mode (more than one list item can be selected)."
-              },
-              {
-                "value": "\"Delete\"",
-                "description": "Delete mode (only one list item can be deleted via provided delete button)"
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Single\""
-              },
-              {
-                "value": "\"SingleStart\""
-              },
-              {
-                "value": "\"SingleEnd\""
-              },
-              {
-                "value": "\"SingleAuto\""
-              },
-              {
-                "value": "\"Multiple\""
-              },
-              {
-                "value": "\"Delete\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the selection mode of the component. Since the tree uses a `List` to display its structure,\nthe tree modes are exactly the same as the list modes, and are all applicable.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TreeDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "walk",
-          "description": "Perform Depth-First-Search walk on the tree and run a callback on each node",
-          "params": [
-            {
-              "name": "callback",
-              "type": {
-                "name": "WalkCallback"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "void"
-          }
-        }
-      ]
-    },
-    "TreeItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TreeItem` represents a node in a tree structure, shown as a `List`.\n\nThis is the item to use inside a `Tree`.\nYou can represent an arbitrary tree structure by recursively nesting tree items.\n\n\n\n__Note:__ This is a UI5 Web Component! [TreeItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TreeItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the component.\n\n**Note:** Use `TreeItem` or `TreeItemCustom`\n\n__Supported Node Type/s:__ `Array<TreeItemBase>`"
-        },
-        "deleteButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `Button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "image": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "**Note:** While the slot allows option for setting custom avatar, to match the\ndesign guidelines, please use the `Avatar` with size XS.\n\n**Note:** If bigger `Avatar` needs to be used, then the size of the\n`TreeItem` should be customized in order to fit.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"image\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onDetailClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TreeItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ListItemAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents**."
-        },
-        "additionalText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `additionalText`, displayed in the end of the tree item."
-        },
-        "additionalTextState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the state of the `additionalText`.\n\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "expanded": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the tree list item will show a collapse or expand icon inside its toggle button.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hasChildren": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the tree node has children, even if currently no other tree nodes are slotted inside.\n\n**Note:** This property is useful for showing big tree structures where not all nodes are initially loaded due to performance reasons.\nSet this to `true` for nodes you intend to load lazily, when the user clicks the expand button.\nIt is not necessary to set this property otherwise. If a tree item has children, the expand button will be displayed anyway.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "highlight": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\" | Highlight",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "If set, an icon will be displayed before the text of the tree list item."
-        },
-        "indeterminate": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the selection of a tree node is displayed as partially selected.\n\n**Note:** The indeterminate state can be set only programmatically and can’t be achieved by user\ninteraction, meaning that the resulting visual state depends on the values of the `indeterminate`\nand `selected` properties:\n\n-  If a tree node has both `selected` and `indeterminate` set to `true`, it is displayed as partially selected.\n-  If a tree node has `selected` set to `true` and `indeterminate` set to `false`, it is displayed as selected.\n-  If a tree node has `selected` set to `false`, it is displayed as not selected regardless of the value of the `indeterminate` property.\n\n**Note:** This property takes effect only when the `Tree` is in `Multiple` mode.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "movable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the item is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "navigated": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tree item."
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
-            "value": [
-              {
-                "value": "\"Inactive\"",
-                "description": "Indicates the list item does not have any active feedback when item is pressed."
-              },
-              {
-                "value": "\"Active\"",
-                "description": "Indicates that the item is clickable via active feedback when item is pressed."
-              },
-              {
-                "value": "\"Detail\"",
-                "description": "Enables detail button of the list item that fires detail-click event."
-              },
-              {
-                "value": "\"Navigation\"",
-                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
-              },
-              {
-                "value": "\"Inactive\""
-              },
-              {
-                "value": "\"Active\""
-              },
-              {
-                "value": "\"Detail\""
-              },
-              {
-                "value": "\"Navigation\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
-          "defaultValue": {
-            "value": "\"Active\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TreeItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "toggle",
-          "description": "Call this method to manually switch the `expanded` state of a tree item.",
-          "params": [],
-          "returns": {
-            "type": "void"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "additionalText",
-          "description": "Used to style the additionalText of the tree list item"
-        },
-        {
-          "name": "icon",
-          "description": "Used to style the icon of the tree list item"
-        },
-        {
-          "name": "title",
-          "description": "Used to style the title of the tree list item"
-        }
-      ]
-    },
-    "TreeItemCustom": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `TreeItemCustom` represents a node in a tree structure, shown as a `List`.\n\nThis is the item to use inside a `Tree`.\nYou can represent an arbitrary tree structure by recursively nesting tree items.\n\nYou can use this item to put any custom content inside the tree item.\n\n\n\n__Note:__ This is a UI5 Web Component! [TreeItemCustom UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/TreeItemCustom) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the component.\n\n**Note:** Use `TreeItem` or `TreeItemCustom`\n\n__Supported Node Type/s:__ `Array<TreeItemBase>`"
-        },
-        "content": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the content of the `TreeItem`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"content\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "deleteButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `Button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "image": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "**Note:** While the slot allows option for setting custom avatar, to match the\ndesign guidelines, please use the `Avatar` with size XS.\n\n**Note:** If bigger `Avatar` needs to be used, then the size of the\n`TreeItem` should be customized in order to fit.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"image\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.10.0](https://github.com/UI5/webcomponents/releases/tag/v2.10.0) of **@ui5/webcomponents**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onDetailClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TreeItemCustomDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ListItemAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the component.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents**."
-        },
-        "additionalTextState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the state of the `additionalText`.\n\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "expanded": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the tree list item will show a collapse or expand icon inside its toggle button.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hasChildren": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the tree node has children, even if currently no other tree nodes are slotted inside.\n\n**Note:** This property is useful for showing big tree structures where not all nodes are initially loaded due to performance reasons.\nSet this to `true` for nodes you intend to load lazily, when the user clicks the expand button.\nIt is not necessary to set this property otherwise. If a tree item has children, the expand button will be displayed anyway.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideSelectionElement": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the tree list item should display the selection element.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "highlight": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\" | Highlight",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "If set, an icon will be displayed before the text of the tree list item."
-        },
-        "indeterminate": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the selection of a tree node is displayed as partially selected.\n\n**Note:** The indeterminate state can be set only programmatically and can’t be achieved by user\ninteraction, meaning that the resulting visual state depends on the values of the `indeterminate`\nand `selected` properties:\n\n-  If a tree node has both `selected` and `indeterminate` set to `true`, it is displayed as partially selected.\n-  If a tree node has `selected` set to `true` and `indeterminate` set to `false`, it is displayed as selected.\n-  If a tree node has `selected` set to `false`, it is displayed as not selected regardless of the value of the `indeterminate` property.\n\n**Note:** This property takes effect only when the `Tree` is in `Multiple` mode.\n\n**Note:** Available since [v1.1.0](https://github.com/UI5/webcomponents/releases/tag/v1.1.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "movable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the item is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "navigated": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents**."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
-            "value": [
-              {
-                "value": "\"Inactive\"",
-                "description": "Indicates the list item does not have any active feedback when item is pressed."
-              },
-              {
-                "value": "\"Active\"",
-                "description": "Indicates that the item is clickable via active feedback when item is pressed."
-              },
-              {
-                "value": "\"Detail\"",
-                "description": "Enables detail button of the list item that fires detail-click event."
-              },
-              {
-                "value": "\"Navigation\"",
-                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
-              },
-              {
-                "value": "\"Inactive\""
-              },
-              {
-                "value": "\"Active\""
-              },
-              {
-                "value": "\"Detail\""
-              },
-              {
-                "value": "\"Navigation\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
-          "defaultValue": {
-            "value": "\"Active\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TreeItemCustomDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "toggle",
-          "description": "Call this method to manually switch the `expanded` state of a tree item.",
-          "params": [],
-          "returns": {
-            "type": "void"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "additionalText",
-          "description": "Used to style the additionalText of the tree list item"
-        },
-        {
-          "name": "icon",
-          "description": "Used to style the icon of the tree list item"
-        },
-        {
-          "name": "title",
-          "description": "Used to style the title of the tree list item"
-        }
-      ]
-    },
-    "UploadCollection": {
-      "package": "@ui5/webcomponents-react",
-      "description": "This component allows you to represent files before uploading them to a server, with the help of `UploadCollectionItem`.\nIt also allows you to show already uploaded files.\n\n\n\n`import \"@ui5/webcomponents-fiori/dist/UploadCollectionItem.js\";` (for `UploadCollectionItem`)\n\n__Note:__ This is a UI5 Web Component! [UploadCollection UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UploadCollection) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the `UploadCollection`.\n\n**Note:** Use `UploadCollectionItem` for the intended design.\n\n__Supported Node Type/s:__ `Array<UploadCollectionItem>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the `UploadCollection` header.\n\n**Note:** If `header` slot is provided,\nthe labelling of the `UploadCollection` is a responsibility of the application developer.\n`accessibleName` should be used.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onItemDelete": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UploadCollectionDomRef, UploadCollectionItemDeleteEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when an element is dropped inside the drag and drop overlay.\n\n**Note:** The `drop` event is fired only when elements are dropped within the drag and drop overlay and ignored for the other parts of the `UploadCollection`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "dataTransfer",
-                "type": "DataTransfer",
-                "description": "The `drop` event operation data."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UploadCollectionDomRef, UploadCollectionSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when selection is changed by user interaction\nin `Single` and `Multiple` modes.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "selectedItems",
-                "type": "Array",
-                "description": "An array of the selected items."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "hideDragOverlay": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "By default there will be drag and drop overlay shown over the `UploadCollection` when files\nare dragged. If you don't intend to use drag and drop, set this property.\n\n**Note:** It is up to the application developer to add handler for `drop` event and handle it.\n`UploadCollection` only displays an overlay.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "noDataDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Allows you to set your own text for the 'No data' description."
-        },
-        "noDataHeaderLevel": {
-          "type": {
-            "name": "enum",
-            "raw": "TitleLevel | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\"",
-            "value": [
-              {
-                "value": "\"H1\"",
-                "description": "Renders `h1` tag."
-              },
-              {
-                "value": "\"H2\"",
-                "description": "Renders `h2` tag."
-              },
-              {
-                "value": "\"H3\"",
-                "description": "Renders `h3` tag."
-              },
-              {
-                "value": "\"H4\"",
-                "description": "Renders `h4` tag."
-              },
-              {
-                "value": "\"H5\"",
-                "description": "Renders `h5` tag."
-              },
-              {
-                "value": "\"H6\"",
-                "description": "Renders `h6` tag."
-              },
-              {
-                "value": "\"H1\""
-              },
-              {
-                "value": "\"H2\""
-              },
-              {
-                "value": "\"H3\""
-              },
-              {
-                "value": "\"H4\""
-              },
-              {
-                "value": "\"H5\""
-              },
-              {
-                "value": "\"H6\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the header level of the 'No data' text.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"H2\""
-          }
-        },
-        "noDataText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Allows you to set your own text for the 'No data' text."
-        },
-        "selectionMode": {
-          "type": {
-            "name": "enum",
-            "raw": "UploadCollectionSelectionMode | \"None\" | \"Single\" | \"SingleStart\" | \"SingleEnd\" | \"SingleAuto\" | \"Multiple\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "Default mode (no selection)."
-              },
-              {
-                "value": "\"Single\"",
-                "description": "Right-positioned single selection mode (only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleStart\"",
-                "description": "Left-positioned single selection mode (only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleEnd\"",
-                "description": "Selected item is highlighted but no selection element is visible\n(only one list item can be selected)."
-              },
-              {
-                "value": "\"SingleAuto\"",
-                "description": "Selected item is highlighted and selection is changed upon arrow navigation\n(only one list item can be selected - this is always the focused item)."
-              },
-              {
-                "value": "\"Multiple\"",
-                "description": "Multi selection mode (more than one list item can be selected)."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Single\""
-              },
-              {
-                "value": "\"SingleStart\""
-              },
-              {
-                "value": "\"SingleEnd\""
-              },
-              {
-                "value": "\"SingleAuto\""
-              },
-              {
-                "value": "\"Multiple\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the selection mode of the `UploadCollection`.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UploadCollectionDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "UploadCollectionItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A component to be used within the `UploadCollection`.\n\n\n\n__Note:__ This is a UI5 Web Component! [UploadCollectionItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UploadCollectionItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Hold the description of the `UploadCollectionItem`. Will be shown below the file name.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "deleteButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `ui5-button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "thumbnail": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "A thumbnail, which will be shown in the beginning of the `UploadCollectionItem`.\n\n**Note:** Use `ui5-icon` or `img` for the intended design.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"thumbnail\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onDetailClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UploadCollectionItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onFileNameClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UploadCollectionItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the file name is clicked.\n\n**Note:** This event is only available when `fileNameClickable` property is `true`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onRename": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UploadCollectionItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `fileName` property gets changed.\n\n**Note:** An edit button is displayed on each item,\nwhen the `UploadCollectionItem` `type` property is set to `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onRetry": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UploadCollectionItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the retry button is pressed.\n\n**Note:** Retry button is displayed when `uploadState` property is set to `Error`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onTerminate": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UploadCollectionItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the terminate button is pressed.\n\n**Note:** Terminate button is displayed when `uploadState` property is set to `Uploading`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ListItemAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "disableDeleteButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Disables the delete button.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "file": {
-          "type": {
-            "name": "File"
-          },
-          "required": false,
-          "description": "Holds an instance of `File` associated with this item.",
-          "defaultValue": {
-            "value": "null"
-          }
-        },
-        "fileName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "The name of the file."
-        },
-        "fileNameClickable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "If set to `true` the file name will be clickable and it will fire `file-name-click` event upon click.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideDeleteButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Hides the delete button.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideRetryButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Hides the retry button when `uploadState` property is `Error`.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "hideTerminateButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Hides the terminate button when `uploadState` property is `Uploading`.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "highlight": {
-          "type": {
-            "name": "enum",
-            "raw": "Highlight | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "navigated": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "progress": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The upload progress in percentage.\n\n**Note:** Expected values are in the interval [0, 100].",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents-fiori**."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
-            "value": [
-              {
-                "value": "\"Inactive\"",
-                "description": "Indicates the list item does not have any active feedback when item is pressed."
-              },
-              {
-                "value": "\"Active\"",
-                "description": "Indicates that the item is clickable via active feedback when item is pressed."
-              },
-              {
-                "value": "\"Detail\"",
-                "description": "Enables detail button of the list item that fires detail-click event."
-              },
-              {
-                "value": "\"Navigation\"",
-                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
-              },
-              {
-                "value": "\"Inactive\""
-              },
-              {
-                "value": "\"Active\""
-              },
-              {
-                "value": "\"Detail\""
-              },
-              {
-                "value": "\"Navigation\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
-          "defaultValue": {
-            "value": "\"Active\""
-          }
-        },
-        "uploadState": {
-          "type": {
-            "name": "enum",
-            "raw": "UploadState | \"Complete\" | \"Error\" | \"Ready\" | \"Uploading\"",
-            "value": [
-              {
-                "value": "\"Complete\"",
-                "description": "The file has been uploaded successfully."
-              },
-              {
-                "value": "\"Error\"",
-                "description": "The file cannot be uploaded due to an error."
-              },
-              {
-                "value": "\"Ready\"",
-                "description": "The file is awaiting an explicit command to start being uploaded."
-              },
-              {
-                "value": "\"Uploading\"",
-                "description": "The file is currently being uploaded."
-              },
-              {
-                "value": "\"Complete\""
-              },
-              {
-                "value": "\"Error\""
-              },
-              {
-                "value": "\"Ready\""
-              },
-              {
-                "value": "\"Uploading\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Upload state.\n\nDepending on this property, the item displays the following:\n\n- `Ready` - progress indicator is displayed.\n- `Uploading` - progress indicator and terminate button are displayed. When the terminate button is pressed, `terminate` event is fired.\n- `Error` - progress indicator and retry button are displayed. When the retry button is pressed, `retry` event is fired.\n- `Complete` - progress indicator is not displayed.",
-          "defaultValue": {
-            "value": "\"Ready\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UploadCollectionItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "UserMenu": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `UserMenu` is an SAP Fiori specific web component that is used in `ShellBar`\nand allows the user to easily see information and settings for the current user and all other logged in accounts.\n\n\n\n`import \"@ui5/webcomponents-fiori/dist/UserMenuItem.js\";` (for `UserMenuItem`)\n\n__Note:__ This is a UI5 Web Component! [UserMenu UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserMenu) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "accounts": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the user accounts.\n\n**Note:** If one item is used, it will be shown as the selected one. If more than one item is used, the first one will be shown as selected unless\nthere is an item with `selected` property set to `true`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"accounts\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<UserMenuAccount>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the menu items.\n\n__Supported Node Type/s:__ `Array<UserMenuItem>`"
-        },
-        "footer": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines custom footer content.\n\n**Note:** When provided, replaces the default \"Sign Out\" button. Use an empty element to hide the footer completely.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"footer\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.20.0](https://github.com/UI5/webcomponents/releases/tag/v2.20.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onAvatarClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the account avatar is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onChangeAccount": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuDomRef, UserMenuOtherAccountClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the account is switched to a different one.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "prevSelectedAccount",
-                "type": "UserMenuAccount",
-                "description": "The previously selected account."
-              },
-              {
-                "name": "selectedAccount",
-                "type": "UserMenuAccount",
-                "description": "The selected account."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when a user menu is close.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onEditAccountsClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the \"Edit Accounts\" button is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onItemClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuDomRef, UserMenuItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a menu item is selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "UserMenuItem",
-                "description": "The selected `user menu item`."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onManageAccountClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the \"Manage Account\" button is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when a user menu is open.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onSignOutClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the \"Sign Out\" button is selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the User Menu is opened.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "opener": {
-          "type": {
-            "name": "string | HTMLElement"
-          },
-          "required": false,
-          "description": "Defines the ID or DOM Reference of the element at which the user menu is shown.\nWhen using this attribute in a declarative way, you must only use the `id` (as a string) of the element at which you want to show the popover.\nYou can only set the `opener` attribute to a DOM Reference when using JavaScript."
-        },
-        "showEditAccounts": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the User Menu shows the Edit Accounts option.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showEditButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the User menu shows edit button.\n\n**Note:** Available since [v2.7.0](https://github.com/UI5/webcomponents/releases/tag/v2.7.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showManageAccount": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the User Menu shows the Manage Account option.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showOtherAccounts": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the User Menu shows the Other Accounts option.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UserMenuDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "UserMenuAccount": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `UserMenuAccount` represents an account in the `UserMenu`.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserMenuAccount UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserMenuAccount) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "additionalInfo": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines additional information for the user."
-        },
-        "avatarColorScheme": {
-          "type": {
-            "name": "enum",
-            "raw": "AvatarColorScheme | \"Auto\" | \"Accent1\" | \"Accent2\" | \"Accent3\" | \"Accent4\" | \"Accent5\" | \"Accent6\" | \"Accent7\" | \"Accent8\" | \"Accent9\" | \"Accent10\" | \"Placeholder\" | \"Transparent\"",
-            "value": [
-              {
-                "value": "\"Auto\""
-              },
-              {
-                "value": "\"Accent1\""
-              },
-              {
-                "value": "\"Accent2\""
-              },
-              {
-                "value": "\"Accent3\""
-              },
-              {
-                "value": "\"Accent4\""
-              },
-              {
-                "value": "\"Accent5\""
-              },
-              {
-                "value": "\"Accent6\""
-              },
-              {
-                "value": "\"Accent7\""
-              },
-              {
-                "value": "\"Accent8\""
-              },
-              {
-                "value": "\"Accent9\""
-              },
-              {
-                "value": "\"Accent10\""
-              },
-              {
-                "value": "\"Placeholder\""
-              },
-              {
-                "value": "\"Transparent\""
-              },
-              {
-                "value": "\"Auto\""
-              },
-              {
-                "value": "\"Accent1\""
-              },
-              {
-                "value": "\"Accent2\""
-              },
-              {
-                "value": "\"Accent3\""
-              },
-              {
-                "value": "\"Accent4\""
-              },
-              {
-                "value": "\"Accent5\""
-              },
-              {
-                "value": "\"Accent6\""
-              },
-              {
-                "value": "\"Accent7\""
-              },
-              {
-                "value": "\"Accent8\""
-              },
-              {
-                "value": "\"Accent9\""
-              },
-              {
-                "value": "\"Accent10\""
-              },
-              {
-                "value": "\"Placeholder\""
-              },
-              {
-                "value": "\"Transparent\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the background color of the desired image.\nIf `avatarColorScheme` is set to `Auto`, the avatar will be displayed with the `Accent6` color.",
-          "defaultValue": {
-            "value": "\"Auto\""
-          }
-        },
-        "avatarInitials": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the avatar initials of the user."
-        },
-        "avatarSrc": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the avatar image url of the user."
-        },
-        "description": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines description of the user."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether a loading indicator should be shown.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the user is selected.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "subtitleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines additional text of the user."
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the title text of the user."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UserMenuAccountDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "UserMenuItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "`UserMenuItem` is the item to use inside a `UserMenu`.\nAn arbitrary hierarchy structure can be represented by recursively nesting menu items.\n\n### Usage\n\n`UserMenuItem` represents a node in a `UserMenu`. The user menu itself is rendered as a list,\nand each `ui5-menu-item` is represented by a menu item in that menu. Therefore, you should only use\n`UserMenuItem` directly in your apps. The `ui5-menu` menu item is internal for the menu, and not intended for public use.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserMenuItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserMenuItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of this component.\n\n**Note:** Use `UserMenuItem` for the intended design.\n\n__Supported Node Type/s:__ `Array<UserMenuItem>`"
-        },
-        "deleteButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `ui5-button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "endContent": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the components that should be displayed at the end of the menu item.\n\n**Note:** It is highly recommended to slot only components of type `ui5-button`,`ui5-link`\nor `ui5-icon` in order to preserve the intended design. If there are components added to this slot,\nand there is text set in `additionalText`, it will not be displayed. If there are items added to `items` slot,\nnether `additionalText` nor components added to this slot would be displayed.\n\nThe priority of what will be displayed at the end of the menu item is as follows:\nsub-menu arrow (if there are items added in `items` slot) -> components added in `endContent` -> text set to `additionalText`.\n\nApplication developers are responsible for ensuring that interactive elements placed in the `endContent` slot\nhave the correct accessibility behaviour, including their enabled or disabled states.\nThe menu does not manage these aspects when the menu item state changes.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"endContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onBeforeClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, MenuBeforeCloseEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the menu is closed. This event can be cancelled, which will prevent the menu from closing.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "escPressed",
-                "type": "boolean",
-                "description": "Indicates that `ESC` key has triggered the event."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onBeforeOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, MenuBeforeOpenEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired before the menu is opened. This event can be cancelled, which will prevent the menu from opening.\n\n**Note:** Since 1.14.0 the event is also fired before a sub-menu opens.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The menu item that triggers opening of the sub-menu or undefined when fired upon root menu opening."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onCheck": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when an item is checked or unchecked.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the menu is closed.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onDetailClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserMenuItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the menu is opened.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "MenuItemAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaKeyShortcuts**: Indicated the availability of a keyboard shortcuts defined for the menu item.\n\n- **role**: Defines the role of the menu item. If not set, menu item will have default role=\"menuitem\".\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component.\n\n**Note:** Available since [v1.7.0](https://github.com/UI5/webcomponents/releases/tag/v1.7.0) of **@ui5/webcomponents-fiori**."
-        },
-        "additionalText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `additionalText`, displayed in the end of the menu item.\n\n**Note:** The additional text will not be displayed if there are items added in `items` slot or there are\ncomponents added to `endContent` slot.\n\nThe priority of what will be displayed at the end of the menu item is as follows:\nsub-menu arrow (if there are items added in `items` slot) -> components added in `endContent` -> text set to `additionalText`.\n\n**Note:** Available since [v1.8.0](https://github.com/UI5/webcomponents/releases/tag/v1.8.0) of **@ui5/webcomponents-fiori**."
-        },
-        "checked": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether menu item is in checked state.\n\n**Note:** checked state is only taken into account when menu item is added to menu item group\nwith `checkMode` other than `None`.\n\n**Note:** A checked menu item has a checkmark displayed at its end.\n\n**Note:** Available since [v2.12.0](https://github.com/UI5/webcomponents/releases/tag/v2.12.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether menu item is in disabled state.\n\n**Note:** A disabled menu item is noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "highlight": {
-          "type": {
-            "name": "enum",
-            "raw": "Highlight | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed as graphical element within the component.\nThe SAP-icons font provides numerous options.\n\n**Example:**\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the loading indicator will be displayed inside the corresponding menu popover.\n\n**Note:** If set to `true` a busy indicator component will be displayed into the related one to the current menu item sub-menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the loading indicator will be displayed inside the corresponding menu popover.\n\n**Note:** Available since [v1.13.0](https://github.com/UI5/webcomponents/releases/tag/v1.13.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "navigated": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tree item."
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tooltip for the menu item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents-fiori**."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
-            "value": [
-              {
-                "value": "\"Inactive\"",
-                "description": "Indicates the list item does not have any active feedback when item is pressed."
-              },
-              {
-                "value": "\"Active\"",
-                "description": "Indicates that the item is clickable via active feedback when item is pressed."
-              },
-              {
-                "value": "\"Detail\"",
-                "description": "Enables detail button of the list item that fires detail-click event."
-              },
-              {
-                "value": "\"Navigation\"",
-                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
-              },
-              {
-                "value": "\"Inactive\""
-              },
-              {
-                "value": "\"Active\""
-              },
-              {
-                "value": "\"Detail\""
-              },
-              {
-                "value": "\"Navigation\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
-          "defaultValue": {
-            "value": "\"Active\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UserMenuItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "UserMenuItemGroup": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `UserMenuItemGroup` component represents a group of items designed for use inside a `UserMenu`.\nItems belonging to the same group should be wrapped by a `UserMenuItemGroup`.\nEach group can have an `itemCheckMode` property, which defines the check mode for the items within the group.\nThe possible values for `itemCheckMode` are:\n- 'None' (default) - no items can be checked\n- 'Single' - Only one item can be checked at a time\n- 'Multiple' - Multiple items can be checked simultaneously\n\n**Note:** If the `itemCheckMode` property is set to 'Single', only one item can remain checked at any given time.\nIf multiple items are marked as checked, the last checked item will take precedence.\n\n### Usage\n\n`UserMenuItemGroup` represents a collection of `UserMenuItem` components that can have the same check mode.\nThe items are addeed to the group's `items` slot.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserMenuItemGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserMenuItemGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of this component.\n**Note:** The slot can hold any combination of components of type `ui5-menu-item` or `ui5-menu-separator` or both.\n\n__Supported Node Type/s:__ `Array<IMenuItem>`"
-        },
-        "checkMode": {
-          "type": {
-            "name": "enum",
-            "raw": "MenuItemGroupCheckMode | \"None\" | \"Single\" | \"Multiple\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "default type (items in a group cannot be checked)"
-              },
-              {
-                "value": "\"Single\"",
-                "description": "Single item check mode (only one item in a group can be checked at a time)"
-              },
-              {
-                "value": "\"Multiple\"",
-                "description": "Multiple items check mode (multiple items in a group can be checked at a time)"
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Single\""
-              },
-              {
-                "value": "\"Multiple\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component's check mode.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UserMenuItemGroupDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "UserSettingsAccountView": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `UserSettingsAccountView` represents a view displayed in the `UserSettingsItem`.\n\n__Note:__ This is a UI5 Web Component! [UserSettingsAccountView UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsAccountView) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "account": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the user account.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"account\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<UserMenuAccount>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the view.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onEditAccountsClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserSettingsAccountViewDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `Edit Accounts` button is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onManageAccountClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserSettingsAccountViewDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the `Manage Account` button is selected.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "secondary": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the view is secondary. It is relevant only if the view is used in `pages` slot of `UserSettingsItem`\nand controls the visibility of the back button.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the view is selected. There can be just one selected view at a time.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showManageAccount": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the User Menu shows the `Manage Account` option.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the title text of the user settings view."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UserSettingsAccountViewDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "UserSettingsAppearanceView": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `UserSettingsAppearanceView` represents a view displayed in the `UserSettingsItem`.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserSettingsAppearanceView UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsAppearanceView) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "additionalContent": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines additional content displayed below the items list.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"additionalContent\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the component.\n\n__Supported Node Type/s:__ `Array<UserSettingsAppearanceViewGroup | UserSettingsAppearanceViewItem>`"
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserSettingsAppearanceViewDomRef, UserSettingsAppearanceViewItemSelectEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when an item is selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "UserSettingsAppearanceViewItem",
-                "description": "The selected `user settings appearance view item`."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "secondary": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the view is secondary. It is relevant only if the view is used in `pages` slot of `UserSettingsItem`\nand controls the visibility of the back button.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the view is selected. There can be just one selected view at a time.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the title text of the user settings view."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UserSettingsAppearanceViewDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "UserSettingsAppearanceViewGroup": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `UserSettingsAppearanceViewGroup` is a special list item group used to group appearance view items.\n\nThis is the item to use inside a `UserSettingsAppearanceView`.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserSettingsAppearanceViewGroup UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsAppearanceViewGroup) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the items of the <code>ui5-user-settings-appearance-view-group</code>.\n\n__Supported Node Type/s:__ `Array<UserSettingsAppearanceViewItem>`"
-        },
-        "header": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the header of the component.\n\n**Note:** Using this slot, the default header text of group and the value of `headerText` property will be overwritten.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"header\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<ListItemBase>`"
-        },
-        "onMove": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserSettingsAppearanceViewGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is dropped onto a drop target.\n\n**Note:** `move` event is fired only if there was a preceding `move-over` with prevented default action.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onMoveOver": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserSettingsAppearanceViewGroupDomRef, ListItemGroupMoveEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a movable list item is moved over a potential drop target during a dragging operation.\n\nIf the new position is valid, prevent the default action of the event using `preventDefault()`.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n**Note:** Available since [v2.1.0](https://github.com/UI5/webcomponents/releases/tag/v2.1.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "destination",
-                "type": "object",
-                "description": "Contains information about the destination of the moved element. Has `element` and `placement` properties."
-              },
-              {
-                "name": "source",
-                "type": "object",
-                "description": "Contains information about the moved element under `element` property."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "headerAccessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible name of the header."
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the header text of the <code>ui5-li-group</code>."
-        },
-        "wrappingType": {
-          "type": {
-            "name": "enum",
-            "raw": "WrappingType | \"None\" | \"Normal\"",
-            "value": [
-              {
-                "value": "\"None\"",
-                "description": "The text will be truncated with an ellipsis."
-              },
-              {
-                "value": "\"Normal\"",
-                "description": "The text will wrap. The words will not be broken based on hyphenation."
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Normal\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines if the text of the component should wrap when it's too long.\nWhen set to \"Normal\", the content (title, description) will be wrapped\nusing the `ui5-expandable-text` component.<br/>\n\nThe text can wrap up to 100 characters on small screens (size S) and\nup to 300 characters on larger screens (size M and above). When text exceeds\nthese limits, it truncates with an ellipsis followed by a text expansion trigger.\n\nAvailable options are:\n- `None` (default) - The text will truncate with an ellipsis.\n- `Normal` - The text will wrap (without truncation).\n\n**Note:** Available since [v2.15.0](https://github.com/UI5/webcomponents/releases/tag/v2.15.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UserSettingsAppearanceViewGroupDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "header",
-          "description": "Used to style the header item of the group"
-        },
-        {
-          "name": "title",
-          "description": "Used to style the title of the group header"
-        }
-      ]
-    },
-    "UserSettingsAppearanceViewItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `UserSettingsAppearanceViewItem` represents a theme/appearance option item\nwithin the `UserSettingsAppearanceView`.\n\nIt displays a theme with an avatar icon, text label, and can be selected.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserSettingsAppearanceViewItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsAppearanceViewItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the component.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "deleteButton": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the delete button, displayed in \"Delete\" mode.\n**Note:** While the slot allows custom buttons, to match\ndesign guidelines, please use the `ui5-button` component.\n**Note:** When the slot is not present, a built-in delete button will be displayed.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"deleteButton\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v1.9.0](https://github.com/UI5/webcomponents/releases/tag/v1.9.0) of **@ui5/webcomponents-fiori**.\n\n__Supported Node Type/s:__ `Array<IButton>`"
-        },
-        "onDetailClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserSettingsAppearanceViewItemDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on the detail button when type is `Detail`.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "ListItemAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\nThe following fields are supported:\n\n- **ariaSetsize**: Defines the number of items in the current set  when not all items in the set are present in the DOM.\n**Note:** The value is an integer reflecting the number of items in the complete set. If the size of the entire set is unknown, set `-1`.\n\n\t- **ariaPosinset**: Defines an element's number or position in the current set when not all items are present in the DOM.\n\t**Note:** The value is an integer greater than or equal to 1, and less than or equal to the size of the set when that size is known.\n\n**Note:** Available since [v1.15.0](https://github.com/UI5/webcomponents/releases/tag/v1.15.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text alternative of the component.\n\n**Note**: If not provided a default text alternative will be set, if present."
-        },
-        "colorScheme": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the color scheme of the avatar.",
-          "defaultValue": {
-            "value": "\"Accent7\""
-          }
-        },
-        "highlight": {
-          "type": {
-            "name": "enum",
-            "raw": "Highlight | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the highlight state of the list items.\nAvailable options are: `\"None\"` (by default), `\"Positive\"`, `\"Critical\"`, `\"Information\"` and `\"Negative\"`.\n\n**Note:** Available since [v1.24](https://github.com/UI5/webcomponents/releases/tag/v1.24) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon of the appearance item.",
-          "defaultValue": {
-            "value": "\"product\""
-          }
-        },
-        "itemKey": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the unique identifier of the item."
-        },
-        "movable": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the item is movable.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "navigated": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "The navigated state of the list item.\nIf set to `true`, a navigation indicator is displayed at the end of the list item.\n\n**Note:** Available since [v1.10.0](https://github.com/UI5/webcomponents/releases/tag/v1.10.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the selected state of the component.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text label displayed for the appearance item."
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the tooltip that would be displayed for the list item.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents-fiori**."
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "ListItemType | \"Inactive\" | \"Active\" | \"Detail\" | \"Navigation\"",
-            "value": [
-              {
-                "value": "\"Inactive\"",
-                "description": "Indicates the list item does not have any active feedback when item is pressed."
-              },
-              {
-                "value": "\"Active\"",
-                "description": "Indicates that the item is clickable via active feedback when item is pressed."
-              },
-              {
-                "value": "\"Detail\"",
-                "description": "Enables detail button of the list item that fires detail-click event."
-              },
-              {
-                "value": "\"Navigation\"",
-                "description": "Enables the type of navigation, which is specified to add an arrow at the end of the items and fires navigate-click event."
-              },
-              {
-                "value": "\"Inactive\""
-              },
-              {
-                "value": "\"Active\""
-              },
-              {
-                "value": "\"Detail\""
-              },
-              {
-                "value": "\"Navigation\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the visual indication and behavior of the list items.\nAvailable options are `Active` (by default), `Inactive`, `Detail` and `Navigation`.\n\n**Note:** When set to `Active` or `Navigation`, the item will provide visual response upon press and hover,\nwhile with type `Inactive` and `Detail` - will not.",
-          "defaultValue": {
-            "value": "\"Active\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UserSettingsAppearanceViewItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "checkbox",
-          "description": "Used to style the checkbox rendered when the list item is in multiple selection mode"
-        },
-        {
-          "name": "content",
-          "description": "Used to style the content area of the list item"
-        },
-        {
-          "name": "delete-button",
-          "description": "Used to style the button rendered when the list item is in delete mode"
-        },
-        {
-          "name": "detail-button",
-          "description": "Used to style the button rendered when the list item is of type detail"
-        },
-        {
-          "name": "native-li",
-          "description": "Used to style the main li tag of the list item"
-        },
-        {
-          "name": "radio",
-          "description": "Used to style the radio button rendered when the list item is in single selection mode"
-        }
-      ]
-    },
-    "UserSettingsDialog": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `UserSettingsDialog` is an SAP Fiori-specific web component used in the `UserMenu`.\nIt allows the user to easily view information and settings for an account.\n\n\n\n__Note:__ This is a UI5 Web Component! [UserSettingsDialog UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsDialog) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the user settings items.\n\n**Note:**  If no setting item is set as `selected`, the first one will be selected.\n\n__Supported Node Type/s:__ `Array<UserSettingsItem>`"
-        },
-        "fixedItems": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the fixed user settings items.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"fixedItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<UserSettingsItem>`"
-        },
-        "onBeforeClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserSettingsDialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired before the settings dialog is closed.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserSettingsDialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when a settings dialog is closed.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserSettingsDialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when a settings dialog is open.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserSettingsDialogDomRef, UserSettingsItemSelectEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when an item is selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "UserSettingsItem",
-                "description": "The selected `user settings item`."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the headerText of the item."
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines, if the User Settings Dialog is opened.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showSearchField": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the Search Field would be displayed.\n\n**Note:** By default the Search Field is not displayed.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UserSettingsDialogDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "UserSettingsItem": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `UserSettingsItem` represents an item in the `UserSettingsDialog`.\n\n\n\nYou can disable the <code>UserSettingsItem</code> by setting the <code>enabled</code> property to <code>false</code>,\nor use the <code>UserSettingsItem</code> in read-only mode by setting the <code>editable</code> property to false.\n\n<b>Note:</b> Disabled and read-only states shouldn't be used together.\n\n__Note:__ This is a UI5 Web Component! [UserSettingsItem UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsItem) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the page views of the user settings item.\n\nIf there are no tab views, the first page view will be shown unless there is selected one. If there is selected page\nview it will be shown no matter if there are tab views.\n\nThe page views are displayed by default if there is no selected tab view.\n\n__Supported Node Type/s:__ `Array<UserSettingsView>`"
-        },
-        "tabs": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the tab views of the user settings item.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"tabs\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<UserSettingsView>`"
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<UserSettingsItemDomRef, UserSettingsItemViewSelectEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when a selected view changed.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "view",
-                "type": "UserSettingsView",
-                "description": "The selected `view`."
-              }
-            ],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "headerText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the headerText of the item."
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon of the component.",
-          "defaultValue": {
-            "value": "\"globe\""
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether a loading indicator should be shown.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "loadingReason": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Indicates why the control is in loading state."
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Shows item tab.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the user settings item."
-        },
-        "tooltip": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the tooltip of the component.\n\nA tooltip attribute should be provided to represent the meaning or function when the component is collapsed and only the icon is visible."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UserSettingsItemDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "UserSettingsView": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `UserSettingsView` represents a view displayed in the `UserSettingsItem`.\n\n__Note:__ This is a UI5 Web Component! [UserSettingsView UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/UserSettingsView) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the content of the view.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "secondary": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the view is secondary. It is relevant only if the view is used in `pages` slot of `UserSettingsItem`\nand controls the visibility of the back button.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the view is selected. There can be just one selected view at a time.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the title text of the user settings view."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<UserSettingsViewDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ViewSettingsDialog": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `ViewSettingsDialog` component helps the user to sort data within a list or a table.\nIt consists of several lists like `Sort order` which is built-in and `Sort By` and `Filter By` lists,\nfor which you must be provide items(`SortItem` & `FilterItem` respectively)\nThese options can be used to create sorters for a table.\n\nThe `ViewSettingsDialog` interrupts the current application processing as it is the only focused UI element and\nthe main screen is dimmed/blocked.\nThe `ViewSettingsDialog` is modal, which means that user action is required before returning to the parent window is possible.\n\n### Structure\nA `ViewSettingsDialog` consists of a header, content, and a footer for action buttons.\nThe `ViewSettingsDialog` is usually displayed at the center of the screen.\n\n### Responsive Behavior\n`ViewSettingsDialog` stretches on full screen on phones.\n\n\n\n__Note:__ This is a UI5 Web Component! [ViewSettingsDialog UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/ViewSettingsDialog) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "filterItems": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the `filterItems` list.\n\n**Note:** If you want to use this slot, you need to import used item: `import \"@ui5/webcomponents-fiori/dist/FilterItem.js\";`\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"filterItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<FilterItem>`"
-        },
-        "groupItems": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the list of items against which the user could group data.\n\n**Note:** If you want to use this slot, you need to import used item: `import \"@ui5/webcomponents-fiori/dist/GroupItem.js\";`\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"groupItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<GroupItem>`"
-        },
-        "sortItems": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the list of items against which the user could sort data.\n\n**Note:** If you want to use this slot, you need to import used item: `import \"@ui5/webcomponents-fiori/dist/SortItem.js\";`\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"sortItems\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<SortItem>`"
-        },
-        "onBeforeOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ViewSettingsDialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired before the component is opened.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onCancel": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ViewSettingsDialogDomRef, ViewSettingsDialogCancelEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when cancel button is activated.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "filters",
-                "type": "Array",
-                "description": "The selected filters items."
-              },
-              {
-                "name": "groupBy",
-                "type": "String",
-                "description": "The currently selected `ui5-group-item` text attribute."
-              },
-              {
-                "name": "groupByItem",
-                "type": "HTMLElement",
-                "description": "The currently selected `ui5-group-item`."
-              },
-              {
-                "name": "groupDescending",
-                "type": "Boolean",
-                "description": "The selected group order (true = descending, false = ascending)."
-              },
-              {
-                "name": "groupOrder",
-                "type": "String",
-                "description": "The current group order selected."
-              },
-              {
-                "name": "sortBy",
-                "type": "String",
-                "description": "The currently selected `ui5-sort-item` text attribute."
-              },
-              {
-                "name": "sortByItem",
-                "type": "HTMLElement",
-                "description": "The currently selected `ui5-sort-item`."
-              },
-              {
-                "name": "sortDescending",
-                "type": "Boolean",
-                "description": "The selected sort order (true = descending, false = ascending)."
-              },
-              {
-                "name": "sortOrder",
-                "type": "String",
-                "description": "The current sort order selected."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ViewSettingsDialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the dialog is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onConfirm": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ViewSettingsDialogDomRef, ViewSettingsDialogConfirmEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when confirmation button is activated.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "filters",
-                "type": "Array",
-                "description": "The selected filters items."
-              },
-              {
-                "name": "groupBy",
-                "type": "String",
-                "description": "The currently selected `ui5-group-item` text attribute."
-              },
-              {
-                "name": "groupByItem",
-                "type": "HTMLElement",
-                "description": "The currently selected `ui5-group-item`."
-              },
-              {
-                "name": "groupDescending",
-                "type": "Boolean",
-                "description": "The selected group order (true = descending, false = ascending)."
-              },
-              {
-                "name": "groupOrder",
-                "type": "String",
-                "description": "The current group order selected."
-              },
-              {
-                "name": "sortBy",
-                "type": "String",
-                "description": "The currently selected `ui5-sort-item` text attribute."
-              },
-              {
-                "name": "sortByItem",
-                "type": "HTMLElement",
-                "description": "The currently selected `ui5-sort-item`."
-              },
-              {
-                "name": "sortDescending",
-                "type": "Boolean",
-                "description": "The selected sort order (true = descending, false = ascending)."
-              },
-              {
-                "name": "sortOrder",
-                "type": "String",
-                "description": "The current sort order selected."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ViewSettingsDialogDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired after the dialog is opened.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "groupDescending": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the initial group order.\n\n**Note:** Available since [v2.13.0](https://github.com/UI5/webcomponents/releases/tag/v2.13.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates if the dialog is open.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "sortDescending": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the initial sort order.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ViewSettingsDialogDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [
-        {
-          "name": "setConfirmedSettings",
-          "description": "Sets a JavaScript object, as settings to the `ViewSettingsDialog`. This method can be used after the dialog is initially open, as the dialog needs to set its initial settings. The `ViewSettingsDialog` throws an event called \"before-open\", which can be used as a trigger point. The object should have the following format:",
-          "params": [
-            {
-              "name": "settings",
-              "type": {
-                "name": "VSDSettings"
-              },
-              "description": ""
-            }
-          ],
-          "returns": {
-            "type": "void"
-          }
-        }
-      ],
-      "cssParts": [
-        {
-          "name": "header",
-          "description": "Used to style the header."
-        }
-      ]
-    },
-    "Wizard": {
-      "package": "@ui5/webcomponents-react",
-      "description": "The `Wizard` helps users to complete a complex task by dividing it into sections and guiding them through it.\nIt has two main areas - a navigation area at the top showing the step sequence and a content area below it.\n\n### Structure\n#### Navigation area\nThe top most area of the `Wizard` is occupied by the navigation area.\nIt shows the sequence of steps, where the recommended number of steps is between 3 and 8 steps.\n\n-  Steps can have different visual representations - numbers or icons.\n-  Steps might have labels for better readability - titleText and subTitleText.\n-  Steps are defined by using the `WizardStep` as slotted element within the `Wizard`.\n\n**Note:** If no selected step is defined, the first step will be auto selected.\n\n**Note:** If multiple selected steps are defined, the last step will be selected.\n\n### Keyboard Handling\nThe user can navigate using the following keyboard shortcuts:\n\n#### Wizard Progress Navigation\n\n\t- [Left] or [Down] - Focus moves backward to the WizardProgressNavAnchors.\n\t- [Up] or [Right] - Focus moves forward to the WizardProgressNavAnchor.\n\t- [Space] / [Enter] or [Return] - Selects an active step\n\t- [Home] or [PAGE UP] - Focus goes to the first step\n\t- [End] or [PAGE DOWN] - Focus goes to the last step\n\n#### Fast Navigation\nThis component provides a build in fast navigation group which can be used via [F6] / [Shift] + [F6] / [Ctrl] + [Alt/Option] / [Down] or [Ctrl] + [Alt/Option] + [Up].\nIn order to use this functionality, you need to import the following module:\n`import \"@ui5/webcomponents-base/dist/features/F6Navigation.js\"`\n\n#### Content\nThe content occupies the main part of the page. It can hold any type of HTML elements.\nIt's defined by using the `WizardStep` as slotted element within the `Wizard`.\n\n### Scrolling\nThe component handles user scrolling by selecting the closest step, based on the current scroll position\nand scrolls to particular place, when the user clicks on the step within the navigation area.\n\n**Important:** In order the component's scrolling behaviour to work, it has to be limited from the outside parent element in terms of height.\nThe component or its parent has to be given percentage or absolute height. Otherwise, the component will be scrolled out with the entire page.\n\n**For example:**\n\n```html\n<ui5-dialog style=\"height: 80%\">\n\t<Wizard></Wizard>\n</ui5-dialog>\n```\n\n#### Moving to next step\nThe `WizardStep` provides the necessary API and it's up to the user of the component to use it to move to the next step.\nYou have to set its `selected` property (and remove the `disabled` one if set) to `true`.\nThe `Wizard` will automatically scroll to the content of the newly selected step.\n\nThe Fiori 3 guidelines recommends having a \"nextStep\" button in the content area.\nYou can place a button, or any other type of element to trigger step change, inside the `WizardStep`,\nand show/hide it when certain fields are filled or user defined criteria is met.\n\n### Usage\n#### When to use:\nWhen the user has to accomplish a long or unfamiliar task.\n\n#### When not to use:\nWhen the task has less than 3 steps.\n\n### Responsive Behavior\nOn small widths the step's titleText, subtitleText and separators in the navigation area shrink and from particular point the steps are grouped together and overlap.\nTapping on them will show a popover to select the step to navigate to. On mobile device, the grouped steps are presented within a dialog.\n\n (includes <ui5-wizard-step/>)\n\n__Note:__ This is a UI5 Web Component! [Wizard UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/Wizard) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the steps.\n\n**Note:** Use the available `WizardStep` component.\n\n__Supported Node Type/s:__ `Array<WizardStep>`"
-        },
-        "onStepChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<WizardDomRef, WizardStepChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the step is changed by user interaction - either with scrolling,\nor by clicking on the steps within the component header.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "previousStep",
-                "type": "WizardStep",
-                "description": "The previous step."
-              },
-              {
-                "name": "step",
-                "type": "WizardStep",
-                "description": "The new step."
-              },
-              {
-                "name": "withScroll",
-                "type": "boolean",
-                "description": "true when the event occurs due to user scrolling."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "contentLayout": {
-          "type": {
-            "name": "enum",
-            "raw": "WizardContentLayout | \"MultipleSteps\" | \"SingleStep\"",
-            "value": [
-              {
-                "value": "\"MultipleSteps\"",
-                "description": "Display the content of the `ui5-wizard` as multiple steps in a scroll section."
-              },
-              {
-                "value": "\"SingleStep\"",
-                "description": "Display the content of the `ui5-wizard` as single step."
-              },
-              {
-                "value": "\"MultipleSteps\""
-              },
-              {
-                "value": "\"SingleStep\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines how the content of the `Wizard` would be visualized.\n\n**Note:** Available since [v1.14.0](https://github.com/UI5/webcomponents/releases/tag/v1.14.0) of **@ui5/webcomponents-fiori**.",
-          "defaultValue": {
-            "value": "\"MultipleSteps\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<WizardDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "navigator",
-          "description": "Used to style the progress navigator of the `ui5-wizard`."
-        },
-        {
-          "name": "step-content",
-          "description": "Used to style a `ui5-wizard-step` container."
-        }
-      ]
-    },
-    "WizardStep": {
-      "package": "@ui5/webcomponents-react",
-      "description": "A component that represents a logical step as part of the `Wizard`.\nIt is meant to aggregate arbitrary HTML elements that form the content of a single step.\n\n### Structure\n\n- Each wizard step has arbitrary content.\n- Each wizard step might have texts - defined by the `titleText` and `subtitleText` properties.\n- Each wizard step might have an icon - defined by the `icon` property.\n- Each wizard step might display a number in place of the `icon`, when it's missing.\n\n### Usage\nThe `WizardStep` component should be used only as slot of the `Wizard` component\nand should not be used standalone.\n\n__Note:__ This is a UI5 Web Component! [WizardStep UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/fiori/WizardStep) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the step content.\n\n__Supported Node Type/s:__ `Array<Node>`"
-        },
-        "branching": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "When `branching` is enabled a dashed line would be displayed after the step,\nmeant to indicate that the next step is not yet known and depends on user choice in the current step.\n\n**Note:** It is recommended to use `branching` on the last known step\nand later add new steps when it becomes clear how the wizard flow should continue.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the step is `disabled`. When disabled the step is displayed,\nbut the user can't select the step by clicking or navigate to it with scrolling.\n\n**Note:** Step can't be `selected` and `disabled` at the same time.\nIn this case the `selected` property would take precedence.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `icon` of the step.\n\n**Note:** The icon is displayed in the `Wizard` navigation header.\n\nThe SAP-icons font provides numerous options.\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "selected": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the step's `selected` state - the step that is currently active.\n\n**Note:** Step can't be `selected` and `disabled` at the same time.\nIn this case the `selected` property would take precedence.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "subtitleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `subtitleText` of the step.\n\n**Note:** the text is displayed in the `Wizard` navigation header."
-        },
-        "titleText": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the `titleText` of the step.\n\n**Note:** The text is displayed in the `Wizard` navigation header."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<WizardStepDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    }
-  },
-  "charts": {
-    "BarChart": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "A `BarChart` is a data visualization where each category is represented by a rectangle, with the width of the rectangle being proportional to the values being plotted.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "dimensions": {
-          "type": {
-            "name": "DimensionConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x axis"
-        },
-        "measures": {
-          "type": {
-            "name": "MeasureConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object is defining one bar in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this bar should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_OrderedColor_` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this bar.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: bar width, defaults to `auto`\n- `opacity`: bar opacity, defaults to `1`\n- `stackId`: bars with the same stackId will be stacked\n- `highlightColor`: function will be called to define a custom color of a specific element which matches the\n   defined condition. Overwrites code>color</code> of the element."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "dataset": {
-          "type": {
-            "name": "Record<string, unknown>[]"
-          },
-          "required": false,
-          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
-        },
-        "noLegend": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when clicked anywhere in the chart."
-        },
-        "onDataPointClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
-        },
-        "onLegendClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noAnimation` disables all chart animations when set to `true`."
-        },
-        "chartConfig": {
-          "type": {
-            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
-          },
-          "required": false,
-          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
-        },
-        "tooltipConfig": {
-          "type": {
-            "name": "TooltipProps<string | number | (string | number)[], string | number>"
-          },
-          "required": false,
-          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
-        },
-        "syncId": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
-        },
-        "ChartPlaceholder": {
-          "type": {
-            "name": "ComponentType"
-          },
-          "required": false,
-          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "BulletChart": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "The `BulletChart` is used to compare primary and secondary (comparison) values. The primary and additional values\nare rendered as a stacked Bar Chart while the comparison value is displayed as a line above.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "dimensions": {
-          "type": {
-            "name": "DimensionConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x axis"
-        },
-        "measures": {
-          "type": {
-            "name": "MeasureConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object is defining one element in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this element should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n- `type`: string which chart element (value type) to show. Possible values: `primary`, `comparison`, `additional`.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this element.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: width of the current chart element, defaults to `1` for `lines` and `20` for bars\n- `opacity`: element opacity, defaults to `1`\n- `highlightColor`: function will be called to define a custom color of a specific element which matches the\n   defined condition. Overwrites code>color</code> of the element."
-        },
-        "layout": {
-          "type": {
-            "name": "enum",
-            "raw": "\"horizontal\" | \"vertical\"",
-            "value": [
-              {
-                "value": "\"horizontal\""
-              },
-              {
-                "value": "\"vertical\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "layout for showing measures. `horizontal` bars would equal the column chart, `vertical` would be a bar chart.\nDefault Value: `horizontal`",
-          "defaultValue": {
-            "value": "`\"horizontal\"`"
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "dataset": {
-          "type": {
-            "name": "Record<string, unknown>[]"
-          },
-          "required": false,
-          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
-        },
-        "noLegend": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when clicked anywhere in the chart."
-        },
-        "onDataPointClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
-        },
-        "onLegendClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noAnimation` disables all chart animations when set to `true`."
-        },
-        "chartConfig": {
-          "type": {
-            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
-          },
-          "required": false,
-          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
-        },
-        "tooltipConfig": {
-          "type": {
-            "name": "TooltipProps<string | number | (string | number)[], string | number>"
-          },
-          "required": false,
-          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
-        },
-        "syncId": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
-        },
-        "ChartPlaceholder": {
-          "type": {
-            "name": "ComponentType"
-          },
-          "required": false,
-          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ColumnChart": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "A `ColumnChart` is a data visualization where each category is represented by a rectangle, with the height of the rectangle being proportional to the values being plotted.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "dimensions": {
-          "type": {
-            "name": "DimensionConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x axis"
-        },
-        "measures": {
-          "type": {
-            "name": "MeasureConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object is defining one column in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this column should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this column.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: column width, defaults to `auto`\n- `opacity`: column opacity, defaults to `1`\n- `stackId`: columns with the same stackId will be stacked\n- `highlightColor`: function will be called to define a custom color of a specific element which matches the\n   defined condition. Overwrites code>color</code> of the element."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "dataset": {
-          "type": {
-            "name": "Record<string, unknown>[]"
-          },
-          "required": false,
-          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
-        },
-        "noLegend": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when clicked anywhere in the chart."
-        },
-        "onDataPointClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
-        },
-        "onLegendClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noAnimation` disables all chart animations when set to `true`."
-        },
-        "chartConfig": {
-          "type": {
-            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
-          },
-          "required": false,
-          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
-        },
-        "tooltipConfig": {
-          "type": {
-            "name": "TooltipProps<string | number | (string | number)[], string | number>"
-          },
-          "required": false,
-          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
-        },
-        "syncId": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
-        },
-        "ChartPlaceholder": {
-          "type": {
-            "name": "ComponentType"
-          },
-          "required": false,
-          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ColumnChartWithTrend": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "A `ColumnChartWithTrend` is a data visualization where each category is represented by a rectangle, with the height of the rectangle being proportional to the values being plotted amd a trend line which is displayed above the column chart.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "dimensions": {
-          "type": {
-            "name": "DimensionConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x-axis"
-        },
-        "measures": {
-          "type": {
-            "name": "MeasureConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object is defining one column in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this column should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this column.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: column width, defaults to `auto`\n- `opacity`: column opacity, defaults to `1`\n- `stackId`: columns with the same stackId will be stacked\n- `highlightColor`: function will be called to define a custom color of a specific element which matches the\n   defined condition. Overwrites code>color</code> of the element."
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when clicked anywhere in the chart."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "dataset": {
-          "type": {
-            "name": "Record<string, unknown>[]"
-          },
-          "required": false,
-          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
-        },
-        "noLegend": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
-        },
-        "onDataPointClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
-        },
-        "onLegendClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noAnimation` disables all chart animations when set to `true`."
-        },
-        "chartConfig": {
-          "type": {
-            "name": "Omit<ICartesianChartConfig, \"secondYAxis\" | \"secondYAxisConfig\"> & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | ... 1 more ... | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessib..."
-          },
-          "required": false,
-          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
-        },
-        "tooltipConfig": {
-          "type": {
-            "name": "TooltipProps<string | number | (string | number)[], string | number>"
-          },
-          "required": false,
-          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
-        },
-        "ChartPlaceholder": {
-          "type": {
-            "name": "ComponentType"
-          },
-          "required": false,
-          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ComposedChart": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "The `ComposedChart` enables you to combine different chart types in one chart, e.g. showing bars together with lines.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "dimensions": {
-          "type": {
-            "name": "DimensionConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x axis"
-        },
-        "measures": {
-          "type": {
-            "name": "MeasureConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object is defining one element in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this element should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n- `type`: string which chart element to show. Possible values: `line`, `bar`, `area`.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this element.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: width of the current chart element, defaults to `1` for `lines` and `20` for bars\n- `opacity`: element opacity, defaults to `1`\n- `stackId`: bars with the same stackId will be stacked\n- `highlightColor`: function will be called to define a custom color of a specific element which matches the\n   defined condition. Overwrites code>color</code> of the element."
-        },
-        "layout": {
-          "type": {
-            "name": "enum",
-            "raw": "\"horizontal\" | \"vertical\"",
-            "value": [
-              {
-                "value": "\"horizontal\""
-              },
-              {
-                "value": "\"vertical\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "layout for showing measures. `horizontal` bars would equal the column chart, `vertical` would be a bar chart.\nDefault Value: `horizontal`",
-          "defaultValue": {
-            "value": "`\"horizontal\"`"
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "dataset": {
-          "type": {
-            "name": "Record<string, unknown>[]"
-          },
-          "required": false,
-          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
-        },
-        "noLegend": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when clicked anywhere in the chart."
-        },
-        "onDataPointClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
-        },
-        "onLegendClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noAnimation` disables all chart animations when set to `true`."
-        },
-        "chartConfig": {
-          "type": {
-            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
-          },
-          "required": false,
-          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
-        },
-        "tooltipConfig": {
-          "type": {
-            "name": "TooltipProps<string | number | (string | number)[], string | number>"
-          },
-          "required": false,
-          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
-        },
-        "syncId": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
-        },
-        "ChartPlaceholder": {
-          "type": {
-            "name": "ComponentType"
-          },
-          "required": false,
-          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "DonutChart": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "A `DonutChart` is a type of graph that displays data in a circular graph with a cut-out hole in the middle.\nThe pieces of the graph are proportional to the fraction of the whole in each category.\nA `DonutChart` is basically a `PieChart` with a hole.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "centerLabel": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A label to display in the center of the `PieChart`.\nIf you use this prop to display a text, we recommend to increase `chartConfig.innerRadius` to have some free\nspace for the text."
-        },
-        "dimension": {
-          "type": {
-            "name": "IChartDimension"
-          },
-          "required": true,
-          "description": "A object which contains the configuration of the dimension.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs"
-        },
-        "measure": {
-          "type": {
-            "name": "MeasureConfig"
-          },
-          "required": true,
-          "description": "A object which contains the configuration of the measure. The object is defining one pie in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this pie should display. Supports object structures by using <code>'parent.child'</code>.\n\n**Optional properties**\n\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `DataLabel`: a custom component to be used for the data label\n- `colors`: array of any valid CSS Color or CSS Variable. Defaults to the `sapChart_OrderedColor_` colors\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this segment. When passed a function it will be called for each data label with the corresponding chart properties."
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when clicked anywhere in the chart."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "dataset": {
-          "type": {
-            "name": "Record<string, unknown>[]"
-          },
-          "required": false,
-          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
-        },
-        "noLegend": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
-        },
-        "onDataPointClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
-        },
-        "onLegendClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noAnimation` disables all chart animations when set to `true`."
-        },
-        "chartConfig": {
-          "type": {
-            "name": "IPolarChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | \"left\" | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
-          },
-          "required": false,
-          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
-        },
-        "tooltipConfig": {
-          "type": {
-            "name": "TooltipProps<string | number | (string | number)[], string | number>"
-          },
-          "required": false,
-          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
-        },
-        "syncId": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
-        },
-        "ChartPlaceholder": {
-          "type": {
-            "name": "ComponentType"
-          },
-          "required": false,
-          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "LineChart": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "A `LineChart` is a type of chart used to show information that changes over time - it connects multiple dots.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "dimensions": {
-          "type": {
-            "name": "DimensionConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `interval`: number that controls how many ticks are rendered on the x axis"
-        },
-        "measures": {
-          "type": {
-            "name": "MeasureConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object is defining one line in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this line should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this line.\n- `DataLabel`: a custom component to be used for the data label\n- `width`: line width, defaults to `1`\n- `opacity`: line opacity, defaults to `1`\n- `showDot`: Flag whether the line dot should be displayed or not.\n- `lineConfig`: This prop allows passing all [Line Properties](https://recharts.org/en-US/api/Line) of the Recharts library."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "dataset": {
-          "type": {
-            "name": "Record<string, unknown>[]"
-          },
-          "required": false,
-          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
-        },
-        "noLegend": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when clicked anywhere in the chart."
-        },
-        "onDataPointClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
-        },
-        "onLegendClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noAnimation` disables all chart animations when set to `true`."
-        },
-        "chartConfig": {
-          "type": {
-            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
-          },
-          "required": false,
-          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
-        },
-        "tooltipConfig": {
-          "type": {
-            "name": "TooltipProps<string | number | (string | number)[], string | number>"
-          },
-          "required": false,
-          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
-        },
-        "syncId": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
-        },
-        "ChartPlaceholder": {
-          "type": {
-            "name": "ComponentType"
-          },
-          "required": false,
-          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "PieChart": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "A Pie Chart is a type of graph that displays data in a circular graph.\nThe pieces of the graph are proportional to the fraction of the whole in each category.\n\nIn other words, each slice of the pie is relative to the size of that category in the group as a whole.\nThe entire “pie” represents 100 percent of a whole, while the pie “slices” represent portions of the whole.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "centerLabel": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A label to display in the center of the `PieChart`.\nIf you use this prop to display a text, we recommend to increase `chartConfig.innerRadius` to have some free\nspace for the text."
-        },
-        "dimension": {
-          "type": {
-            "name": "IChartDimension"
-          },
-          "required": true,
-          "description": "A object which contains the configuration of the dimension.\n\n**Required Properties**\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs"
-        },
-        "measure": {
-          "type": {
-            "name": "MeasureConfig"
-          },
-          "required": true,
-          "description": "A object which contains the configuration of the measure. The object is defining one pie in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this pie should display. Supports object structures by using <code>'parent.child'</code>.\n\n**Optional properties**\n\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `DataLabel`: a custom component to be used for the data label\n- `colors`: array of any valid CSS Color or CSS Variable. Defaults to the `sapChart_OrderedColor_` colors\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this segment. When passed a function it will be called for each data label with the corresponding chart properties."
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when clicked anywhere in the chart."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "dataset": {
-          "type": {
-            "name": "Record<string, unknown>[]"
-          },
-          "required": false,
-          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
-        },
-        "noLegend": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
-        },
-        "onDataPointClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
-        },
-        "onLegendClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noAnimation` disables all chart animations when set to `true`."
-        },
-        "chartConfig": {
-          "type": {
-            "name": "IPolarChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | \"left\" | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
-          },
-          "required": false,
-          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
-        },
-        "tooltipConfig": {
-          "type": {
-            "name": "TooltipProps<string | number | (string | number)[], string | number>"
-          },
-          "required": false,
-          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
-        },
-        "syncId": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
-        },
-        "ChartPlaceholder": {
-          "type": {
-            "name": "ComponentType"
-          },
-          "required": false,
-          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "RadarChart": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "A radar or spider or web chart is a two-dimensional chart type designed to plot one or more series of values over multiple quantitative variables.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "dimensions": {
-          "type": {
-            "name": "IChartDimension[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object will define one dimension of the chart.\n\n**Required Properties*\n- `accessor`: string containing the path to the dataset key the dimension should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional Properties**\n- `formatter`: function will be called for each data label and allows you to format it according to your needs"
-        },
-        "measures": {
-          "type": {
-            "name": "MeasureConfig[]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object is defining one radar in the chart.\n\n**Required properties**\n- `accessor`: string containing the path to the dataset key this radar should display. Supports object structures by using <code>'parent.child'</code>.\n  Can also be a getter.\n\n**Optional properties**\n\n- `label`: Label to display in legends or tooltips. Falls back to the <code>accessor</code> if not present.\n- `color`: any valid CSS Color or CSS Variable. Defaults to the `sapChart_Ordinal` colors\n- `formatter`: function will be called for each data label and allows you to format it according to your needs\n- `hideDataLabel`: flag whether the data labels should be hidden in the chart for this radar.\n- `DataLabel`: a custom component to be used for the data label\n- `opacity`: radar opacity, defaults to `0.5`"
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "dataset": {
-          "type": {
-            "name": "Record<string, unknown>[]"
-          },
-          "required": false,
-          "description": "The `dataset` is an array of objects that contains all the measures and dimensions.\n\n__Note:__ The values for measure data points must be of type `number`."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
-        },
-        "noLegend": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when clicked anywhere in the chart."
-        },
-        "onDataPointClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
-        },
-        "onLegendClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noAnimation` disables all chart animations when set to `true`."
-        },
-        "chartConfig": {
-          "type": {
-            "name": "ICartesianChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
-          },
-          "required": false,
-          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
-        },
-        "tooltipConfig": {
-          "type": {
-            "name": "TooltipProps<string | number | (string | number)[], string | number>"
-          },
-          "required": false,
-          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
-        },
-        "syncId": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
-        },
-        "ChartPlaceholder": {
-          "type": {
-            "name": "ComponentType"
-          },
-          "required": false,
-          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "RadialChart": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "Displays a ring chart highlighting a current status.\nThe status can be emphasized by using the `color` prop.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "value": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The actual value which defines how much the ring is filled."
-        },
-        "maxValue": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The maximum value of the ring. If `value` >= `maxValue`, the ring will be filled to 100%.\n\n__Default:__ `100`."
-        },
-        "displayValue": {
-          "type": {
-            "name": "string | number"
-          },
-          "required": false,
-          "description": "The value that should be displayed in the center of the `RadialChart`."
-        },
-        "displayValueStyle": {
-          "type": {
-            "name": "CSSProperties"
-          },
-          "required": false,
-          "description": "Font size of the `displayValue`.\n\n__Default values:__\n\n- fontSize: `1.25rem`\n- fill: `ThemingParameters.sapTextColor`"
-        },
-        "color": {
-          "type": {
-            "name": "Color"
-          },
-          "required": false,
-          "description": "A custom color you want to apply to the ring fill. This props accepts any valid CSS color or CSS variable."
-        },
-        "onDataPointClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ value: number; payload: unknown; dataIndex: number; }>) => void"
-          },
-          "required": false,
-          "description": "`onDataPointClick` fires when the user clicks on the filled part of the ring."
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; dataIndex: number; value: number; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when clicked anywhere in the chart."
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noAnimation` disables all chart animations when set to `true`."
-        },
-        "chartConfig": {
-          "type": {
-            "name": "RadialChartConfig"
-          },
-          "required": false,
-          "description": "Defines possible configurations of the internally used [RadialBarChart](https://recharts.org/en-US/api/RadialBarChart).\n\n__Note:__ It is possible to overwrite internally used props. Please use with caution!\n\n__Default values:__\n\n- margin: `{ top: 5, right: 5, bottom: 5, left: 5 }`\n- innerRadius: `\"90%\"`\n- outerRadius: `\"100%\"`"
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ScatterChart": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "\nA `ScatterChart` is a data visualization that displays multiple circles (bubbles) in a two-dimensional plot.\n\nMost commonly, a scatter chart displays the values of three numeric variables,where each observation's data is\nshown by a circle, while the horizontal and vertical positions of the bubble show the values of two other variables.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "dataset": {
-          "type": {
-            "name": "ScatterDataObject[]"
-          },
-          "required": false,
-          "description": "An array of dataset objects. Each object defines a dataset which is displayed.\n\n**Required properties**\n - `data`: array of objects which contains the data.\n\n**Optional properties**\n - `label`: string containing the label of the dataset which is also displayed in the legend.\n - `color`: any valid CSS color or CSS variable. Defaults to the `sapChart_Ordinal` colors.\n - `opacity`: number contains value of opacity of dataset\n\n**Example of dataset:**\n\n<code>\n  <pre>\n   [\n     {\n      label: 'America',\n      opacity: 0.7,\n      data: [\n        {\n          users: 120,\n          sessions: 200,\n          volume: 302\n        },\n        {\n          users: 20,\n          sessions: 230,\n          volume: 392\n        }\n      ]\n     }\n   ]\n  </pre>\n</code>"
-        },
-        "measures": {
-          "type": {
-            "name": "[MeasureConfig, MeasureConfig, MeasureConfig, ...MeasureConfig[]]"
-          },
-          "required": true,
-          "description": "An array of config objects. Each object is defining one axis in the chart.\n\n**Required properties**\n - `accessor`: string containing the path to the dataset key this line should display. Supports object structures by using <code>'parent.child'</code>.\n    Can also be a getter.\n - `axis`: string containing definition of axis. Must be x, y or z data to the axis.\n\n**Optional properties**\n - `label`: Label to display in tooltips. Falls back to the <code>accessor</code> if not present.\n - `formatter`: function will be called for each data label and allows you to format it according to your needs. Also addresses labels of axis."
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: CustomEvent<{ payload: unknown; activePayloads: Record<string, unknown>[]; }>) => void"
-          },
-          "required": false,
-          "description": "Fired when clicked anywhere in the chart."
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "With the help of the `children` prop you can add more svg elements to the chart, e.g. if you want to display\na linear gradient."
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Flag whether the chart should display a loading indicator.\n\nThis can either be a skeleton placeholder shimmer (in case the chart has no data yet) or a `BusyIndicator` on top of the chart (in case the chart has already some data to display)."
-        },
-        "loadingDelay": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the delay in milliseconds, after which the `BusyIndicator` will be visible on the screen.",
-          "defaultValue": {
-            "value": "1000"
-          }
-        },
-        "noLegend": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noLegend` toggles the visibility of the legend below the chart. If this prop is `true`, no legend will be rendered."
-        },
-        "onDataPointClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onDataPointClick` event fires whenever the user clicks on e.g. a  bar in `BarChart` or a point the `LineChart`.\n\nYou can use this event to trigger e.g. navigations or set filters based on the last clicked data point."
-        },
-        "onLegendClick": {
-          "type": {
-            "name": "(event: CustomEvent<any>) => void"
-          },
-          "required": false,
-          "description": "The `onLegendClick` event fires when the user clicks on a label of the legend.\n\nThis can be useful to e.g. show/hide the current dataset in case you have multiple datasets in in your chart.\n@param event"
-        },
-        "noAnimation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "`noAnimation` disables all chart animations when set to `true`."
-        },
-        "chartConfig": {
-          "type": {
-            "name": "IScatterChartConfig & { margin?: { right?: number; left?: number; top?: number; bottom?: number; }; legendPosition?: \"top\" | \"bottom\" | \"middle\"; legendHorizontalAlign?: \"center\" | ... 1 more ... | \"right\"; resizeDebounce?: number; legendConfig?: Omit<...>; accessibilityLayer?: boolean; }"
-          },
-          "required": false,
-          "description": "Defines possible configurations of the chart.\n\n**Properties available on all charts:**\n\n- `margin`: Sets the margin of the chart container. Receives a object with four possible properties (`right`, `left`, `top`, `bottom`) that expect a number as value.\n- `legendPosition`: Vertical position of the legend. Can be one of the following: `\"top\"`,`\"middle\"`, `\"bottom\"` (`\"middle\"` is not supported for: ColumnChartWithTrend, DonutChart, PieChart)\n- `legendHorizontalAlign`: Alignment of the legend. Can be one of the following: `\"left\"`, `\"center\"`, `\"right\"`\n- `resizeDebounce`: Number that sets the amount of delay time the chart waits when resizing.\n- `accessibilityLayer`: Experimental property to improve accessibility. Not supported by all charts and configurations!\n\nPlease note that depending on the chart type, the `chartConfig` prop may accept more properties."
-        },
-        "tooltipConfig": {
-          "type": {
-            "name": "TooltipProps<string | number | (string | number)[], string | number>"
-          },
-          "required": false,
-          "description": "Defines the configuration object for the internally used `recharts` Tooltip popover that is displayed when hovering over data points.\nYou can find all possible configuration properties [here](https://recharts.org/en-US/api/Tooltip).\n\n__Note:__ It is possible to override internally used tooltip props, so please use with caution!"
-        },
-        "syncId": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "A string which defines an id to synchronize two separate charts. Charts with the same syncId synchronize the position\nof the tooltips, the startIndex and the endIndex of the zooming tool."
-        },
-        "ChartPlaceholder": {
-          "type": {
-            "name": "ComponentType"
-          },
-          "required": false,
-          "description": "Injects a custom loading placeholder which is used when no data are available. If the property isn't set the\nstandard loading placeholder of the specific chart is used."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TimelineChart": {
-      "package": "@ui5/webcomponents-react-charts",
-      "description": "> __Experimental Component!__ <br />\n\nA `TimelineChart` is a data visualization chart that can be used to represent\nGantt charts or any other timeline-based visualizations. The component has a\nrich set of various properties that allows the user to:\n* Zoom the chart body to see the visualizations clearer using the mouse wheel.\n* Pan the zoomed chart horizonatally by holding down the left click button.\n* Add annotations to highlight or illustrate different points on the timeline.\n* Use annotations to create custom Timeline visualizations.\n* Choose whether the timeline is discrete or continous.\n* Show relationships between different items on the timeline using different\nconnections.\n\n__Note:__ Charts are custom-built __without__ defined design specifications! They use the Fiori color palette, but functionality and especially accessibility may not meet standard app requirements.\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "dataset": {
-          "type": {
-            "name": "ITimelineChartRow[]"
-          },
-          "required": false,
-          "description": "The data is an array of objects that is displayed on the chart."
-        },
-        "totalDuration": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The total duration of the timeline.",
-          "defaultValue": {
-            "value": "10"
-          }
-        },
-        "width": {
-          "type": {
-            "name": "Width<string | number>"
-          },
-          "required": false,
-          "description": "The total width of the chart. If not supplied, the chart's\nwidth expands to fill its conatainer.",
-          "defaultValue": {
-            "value": "auto"
-          }
-        },
-        "rowHeight": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The height the row of the timeline.",
-          "defaultValue": {
-            "value": "25"
-          }
-        },
-        "isDiscrete": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Whether the timeline is a continuous timeline or broken\ninto discrete sections."
-        },
-        "annotations": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the annonations to be applied on top on the chart.\n\n**Note:** Use the `TimelineChartAnnotation` component here."
-        },
-        "showAnnotation": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Toggles the visibility of the annotations applied to the chart."
-        },
-        "showConnection": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Toggles the visibility of the connections of the task and milestone\nitems in the chart."
-        },
-        "hideTooltip": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Toggles the visibility of the tooltip."
-        },
-        "unit": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "The unit of the duration of the timeline."
-        },
-        "rowTitle": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "The label for the activity axis.",
-          "defaultValue": {
-            "value": "Activities"
-          }
-        },
-        "columnTitle": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "The label for the title of the duration axis.",
-          "defaultValue": {
-            "value": "Duration"
-          }
-        },
-        "discreteLabels": {
-          "type": {
-            "name": "string[]"
-          },
-          "required": false,
-          "description": "The label for the columns if the chart is separated into discrete columns\nbased on if `isDiscrete` is true. If set, the length of this array\n__must__ be equal to the `totalDuration`. If not set, an\narray of numbers with size equal to the `totalDuration` and with values\nstarting from the value __start__ prop of the `TimelineChart` will be used."
-        },
-        "start": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "The starting value of the timeline duration.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "valueFormat": {
-          "type": {
-            "name": "(value: number) => string"
-          },
-          "required": false,
-          "description": "A callback function that is applied to each value in the tick and tootltip\nto format how it is displayed.",
-          "defaultValue": {
-            "value": "(x: number) => x.toFixed(1)"
-          }
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<HTMLDivElement>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    }
-  },
-  "ai": {
-    "Button": {
-      "package": "@ui5/webcomponents-ai-react",
-      "description": "The `Button` component serves as a button for AI-related scenarios. Users can trigger actions by clicking or tapping the `Button`\nor by pressing keyboard keys like [Enter] or [Space].\n\n### Usage\n\nFor the `Button` user interface, you can define one or more button states by placing `ButtonState` components in their default slot.\nEach state has a name for identification and can include text, an icon, and an end icon, as needed for its purpose.\nYou can define a split mode for the `Button`, which will results in displaying an arrow button for additional actions.\n\nYou can choose from a set of predefined designs for `Button` (as in `ui5-button`) to match the desired styling.\n\nThe `Button` can be activated by clicking or tapping it. You can change the button state in the click event handler. When the button is\nin split mode, you can activate the default button action by clicking or tapping it, or by pressing keyboard keys like [Enter] or [Space].\nYou can activate the arrow button by clicking or tapping it, or by pressing keyboard keys like [Arrow Up], [Arrow Down], or [F4].\nTo display additional actions, you can attach a menu to the arrow button.\n\n\n\n__Note:__ This is a UI5 Web Component! [Button UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ai/Button) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the available states of the component.\n**Note:** Although this slot accepts HTML Elements, it is strongly recommended that\nyou only use `ButtonState` components in order to preserve the intended design.\n\n__Supported Node Type/s:__ `Array<ButtonState>`"
-        },
-        "onArrowButtonClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ButtonDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is in split mode and after the arrow button\nis activated either by clicking or tapping it or by using the [Arrow Up] / [Arrow Down],\n[Alt] + [Arrow Up]/ [Arrow Down], or [F4] keyboard keys.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<ButtonDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the component is activated either with a\nmouse/tap or by using the Enter or Space key.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "accessibilityAttributes": {
-          "type": {
-            "name": "AIButtonAccessibilityAttributes"
-          },
-          "required": false,
-          "description": "Defines the additional accessibility attributes that will be applied to the component.\n\nThis property allows for fine-tuned control of ARIA attributes for screen reader support.\nIt accepts an object with the following optional fields:\n\n- **root**: Accessibility attributes that will be applied to the root element.\n - **hasPopup**: Indicates the availability and type of interactive popup element (such as a menu or dialog).\n   Accepts string values: `\"dialog\"`, `\"grid\"`, `\"listbox\"`, `\"menu\"`, or `\"tree\"`.\n - **roleDescription**: Defines a human-readable description for the button's role.\n   Accepts any string value.\n - **title**: Specifies a tooltip or description for screen readers.\n   Accepts any string value.\n- **ariaKeyShortcuts**: Defines keyboard shortcuts that activate or focus the button.\n\n- **arrowButton**: Accessibility attributes that will be applied to the arrow (split) button element.\n - **hasPopup**: Indicates the type of popup triggered by the arrow button.\n   Accepts string values: `\"dialog\"`, `\"grid\"`, `\"listbox\"`, `\"menu\"`, or `\"tree\"`.\n - **expanded**: Indicates whether the popup controlled by the arrow button is currently expanded.\n   Accepts boolean values: `true` or `false`.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "{}"
-          }
-        },
-        "arrowButtonPressed": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines the active state of the arrow button in split mode.\nSet to true when the button is in split mode and a menu with additional options\nis opened by the arrow button. Set back to false when the menu is closed.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "design": {
-          "type": {
-            "name": "enum",
-            "raw": "ButtonDesign | \"Default\" | \"Positive\" | \"Negative\" | \"Transparent\" | \"Emphasized\" | \"Attention\"",
-            "value": [
-              {
-                "value": "\"Default\"",
-                "description": "default type (no special styling)"
-              },
-              {
-                "value": "\"Positive\"",
-                "description": "accept type (green button)"
-              },
-              {
-                "value": "\"Negative\"",
-                "description": "reject style (red button)"
-              },
-              {
-                "value": "\"Transparent\"",
-                "description": "transparent type"
-              },
-              {
-                "value": "\"Emphasized\"",
-                "description": "emphasized type"
-              },
-              {
-                "value": "\"Attention\"",
-                "description": "attention type"
-              },
-              {
-                "value": "\"Default\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Transparent\""
-              },
-              {
-                "value": "\"Emphasized\""
-              },
-              {
-                "value": "\"Attention\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the component design.",
-          "defaultValue": {
-            "value": "\"Default\""
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is disabled.\nA disabled component can't be pressed or\nfocused, and it is not in the tab chain.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "state": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the current state of the component."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ButtonDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "ButtonState": {
-      "package": "@ui5/webcomponents-ai-react",
-      "description": "`ButtonState` is the item to use for defining states of `Button` components.\n\n### Usage\n\n`ButtonState` is an abstract element, representing a state of `Button`. It is meant to be used in the `default` slot\nof `Button` and should not be used as standalone component.\n\n\n\n__Note:__ This is a UI5 Web Component! [ButtonState UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ai/ButtonState) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "endIcon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed as graphical element within the component after the text.\nThe SAP-icons font provides numerous options.\n\n**Example:**\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "icon": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed as graphical element within the component before the text.\nThe SAP-icons font provides numerous options.\n\n**Example:**\n\nSee all the available icons in the [Icon Explorer](https://sdk.openui5.org/test-resources/sap/m/demokit/iconExplorer/webapp/index.html)."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the name of the button state."
-        },
-        "showArrowButton": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines if the component is in split button mode.\n\n**Note:** Available since [v2.6.0](https://github.com/UI5/webcomponents/releases/tag/v2.6.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "text": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the text of the button in this state."
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<ButtonStateDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "Input": {
-      "package": "@ui5/webcomponents-ai-react",
-      "description": "The `Input` component extends the standard `ui5-input` with **AI Writing Assistant** capabilities.\n\n### Structure\n\nThe `Input` consists of the following main parts:\n\n- **Input Field** – Inherits all standard Input behaviors.\n- **AI Action Button** – Appears when focused or loading, providing access to AI-related actions or stopping generation.\n\nThe component automatically determines which elements to render based on its internal state:\n- The AI Button is only shown when there are available `actions`.\n- The version navigation appears only when `totalVersions > 1`.\n\n### Keyboard Support\n\n- **Shift + F4** — Opens the AI menu.\n- **Ctrl + Shift + Z / Y** — Navigates backward/forward between AI-generated versions.\n\n\n\n__Note:__ This is a UI5 Web Component! [Input UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ai/Input) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "actions": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the items of the menu for the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"actions\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the suggestion items.\n\n**Note:** The suggestions would be displayed only if the `showSuggestions`\nproperty is set to `true`.\n\n**Note:** The `<ui5-suggestion-item>`, `<ui5-suggestion-item-group>` and `ui5-suggestion-item-custom` are recommended to be used as suggestion items.\n\n__Supported Node Type/s:__ `Array<IInputSuggestionItem>`"
-        },
-        "icon": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the icon to be displayed in the component.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"icon\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<IIcon>`"
-        },
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n**Note:** If the component has `suggestionItems`,\nthe `valueStateMessage` would be displayed as part of the same popover, if used on desktop, or dialog - on phone.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onButtonClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user selects the AI button.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|❌|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": false
-          }
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter or on focusout.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onClose": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the suggestions picker is closed.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the component changes at each keystroke,\nand when a suggestion item has been selected.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onItemClick": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, MenuItemClickEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when an item from the AI actions menu is clicked.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The currently clicked menu item."
-              },
-              {
-                "name": "text",
-                "type": "string",
-                "description": "The text of the currently clicked menu item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": false
-          }
-        },
-        "onOpen": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the suggestions picker is open.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSelect": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when some text has been selected.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSelectionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, InputSelectionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user navigates to a suggestion item via the ARROW keys,\nas a preview, before the final selection.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "item",
-                "type": "HTMLElement",
-                "description": "The previewed suggestion item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onStopGeneration": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user selects the \"Stop\" button to stop ongoing AI text generation.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onVersionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<InputDomRef, InputVersionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user selects the version navigation buttons.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "backwards",
-                "type": "boolean",
-                "description": "The text of the currently clicked menu item."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": false
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents-ai**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the input.\n\n**Note:** Available since [v2.9.0](https://github.com/UI5/webcomponents/releases/tag/v2.9.0) of **@ui5/webcomponents-ai**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the input."
-        },
-        "currentVersion": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Indicates the index of the currently displayed version.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "filter": {
-          "type": {
-            "name": "enum",
-            "raw": "InputSuggestionsFilter | \"StartsWithPerTerm\" | \"StartsWith\" | \"Contains\" | \"None\"",
-            "value": [
-              {
-                "value": "\"StartsWithPerTerm\"",
-                "description": "Defines filtering by first symbol of each word of item's text."
-              },
-              {
-                "value": "\"StartsWith\"",
-                "description": "Defines filtering by starting symbol of item's text."
-              },
-              {
-                "value": "\"Contains\"",
-                "description": "Defines contains filtering."
-              },
-              {
-                "value": "\"None\"",
-                "description": "Removes any filtering applied while typing"
-              },
-              {
-                "value": "\"StartsWithPerTerm\""
-              },
-              {
-                "value": "\"StartsWith\""
-              },
-              {
-                "value": "\"Contains\""
-              },
-              {
-                "value": "\"None\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the filter type of the component.\n\n**Note:** Available since [v2.19.0](https://github.com/UI5/webcomponents/releases/tag/v2.19.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the AI Writing Assistant is currently loading.\n\nWhen `true`, indicates that an AI action is in progress.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "maxlength": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Sets the maximum number of characters available in the input field.\n\n**Note:** This property is not compatible with the ui5-input type InputType.Number. If the ui5-input type is set to Number, the maxlength value is ignored."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
-        },
-        "noTypeahead": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the value will be autcompleted to match an item\n\n**Note:** Available since [v1.4.0](https://github.com/UI5/webcomponents/releases/tag/v1.4.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "open": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the suggestions picker is open.\nThe picker will not open if the `showSuggestions` property is set to `false`, the input is disabled or the input is readonly.\nThe picker will close automatically and `close` event will be fired if the input is not in the viewport.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showClearIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v1.2.0](https://github.com/UI5/webcomponents/releases/tag/v1.2.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showSuggestions": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should show suggestions, if such are present.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "totalVersions": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Indicates the total number of result versions available.\n\nWhen not set or set to 0, the versioning will be hidden.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "type": {
-          "type": {
-            "name": "enum",
-            "raw": "InputType | \"Text\" | \"Email\" | \"Number\" | \"Password\" | \"Tel\" | \"URL\" | \"Search\"",
-            "value": [
-              {
-                "value": "\"Text\"",
-                "description": "Defines a one-line text input field:"
-              },
-              {
-                "value": "\"Email\"",
-                "description": "Used for input fields that must contain an e-mail address."
-              },
-              {
-                "value": "\"Number\"",
-                "description": "Defines a numeric input field."
-              },
-              {
-                "value": "\"Password\"",
-                "description": "Defines a password field."
-              },
-              {
-                "value": "\"Tel\"",
-                "description": "Used for input fields that should contain a telephone number."
-              },
-              {
-                "value": "\"URL\"",
-                "description": "Used for input fields that should contain a URL address."
-              },
-              {
-                "value": "\"Search\"",
-                "description": "Used for input fields that should contain a search term."
-              },
-              {
-                "value": "\"Text\""
-              },
-              {
-                "value": "\"Email\""
-              },
-              {
-                "value": "\"Number\""
-              },
-              {
-                "value": "\"Password\""
-              },
-              {
-                "value": "\"Tel\""
-              },
-              {
-                "value": "\"URL\""
-              },
-              {
-                "value": "\"Search\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the HTML type of the component.\n\n**Notes:**\n\n- The particular effect of this property differs depending on the browser\nand the current language settings, especially for type `Number`.\n- The property is mostly intended to be used with touch devices\nthat use different soft keyboard layouts depending on the given input type.",
-          "defaultValue": {
-            "value": "\"Text\""
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component.\n\n**Note:** The property is updated upon typing."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "\"None\" | ValueState | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<InputDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "clear-icon",
-          "description": "Used to style the clear icon, which can be pressed to clear user input text"
-        },
-        {
-          "name": "input",
-          "description": "Used to style the native input element"
-        },
-        {
-          "name": "root",
-          "description": "Used to style the root DOM element of the Input component"
-        }
-      ]
-    },
-    "PromptInput": {
-      "package": "@ui5/webcomponents-ai-react",
-      "description": "The `PromptInput` component allows the user to write custom instructions in natural language, so that AI is guided to generate content tailored to user needs.\n\n**Note:** The web component is in an experimental state\n\n\n\n__Note:__ This is a UI5 Web Component! [PromptInput UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ai/PromptInput) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "children": {
-          "type": {
-            "name": "ReactNode | ReactNode[]"
-          },
-          "required": false,
-          "description": "Defines the suggestion items.\n\n**Note:** The suggestions would be displayed only if the `showSuggestions`\nproperty is set to `true`.\n\n**Note:** The `<ui5-suggestion-item>`, `<ui5-suggestion-item-group>` and `ui5-suggestion-item-custom` are recommended to be used as suggestion items.\n\n__Supported Node Type/s:__ `Array<IInputSuggestionItem>`"
-        },
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed,\nwhen the component is in `Information`, `Critical` or `Negative` value state.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<PromptInputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter\nor on focusout.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<PromptInputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the component changes at each keystroke,\nand when a suggestion item has been selected.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSubmit": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<PromptInputDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the input operation has finished by pressing Enter\nor AI button is clicked.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is in disabled state.\n\n**Note:** A disabled component is completely noninteractive.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "label": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the label of the input field.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**."
-        },
-        "maxlength": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Sets the maximum number of characters available in the input field.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**."
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint intended to aid the user with data entry when the\ncomponent has no value.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showClearIcon": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the clear icon of the input will be shown.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showExceededText": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the characters exceeding the maximum allowed character count are visible\nin the component.\n\nIf set to `false`, the user is not allowed to enter more characters than what is set in the\n`maxlength` property.\nIf set to `true` the characters exceeding the `maxlength` value are selected on\npaste and the counter below the component displays their number.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "showSuggestions": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should show suggestions, if such are present.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.\n\n**Note:** Available since [v2.0.0](https://github.com/UI5/webcomponents/releases/tag/v2.0.0) of **@ui5/webcomponents-ai**.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<PromptInputDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": []
-    },
-    "TextArea": {
-      "package": "@ui5/webcomponents-ai-react",
-      "description": "The `TextArea` component extends the standard TextArea with Writing Assistant capabilities.\nIt provides AI-powered text generation, editing suggestions, and version management functionality.\n\n### Structure\nThe `TextArea` consists of the following elements:\n- TextArea: The main text input area with all standard textarea functionality\n- WritingAssistant: Dedicated toolbar containing:\n  - Versioning: A component with left/right navigation buttons and a label for browsing AI-generated versions\n  - AI Button: Opens a menu that can be extended with custom AI generation options through slotting\n\n\n\n__Note:__ This is a UI5 Web Component! [TextArea UI5 Web Component Documentation](https://ui5.github.io/webcomponents/components/ai/TextArea) | [Repository](https://github.com/UI5/webcomponents)\n\n**Note:** This component also accepts all standard HTML attributes (className, style, id, data-*, aria-*, event handlers like onClick, onMouseEnter, etc.) via `CommonProps`.",
-      "props": {
-        "menu": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines a slot for `ui5-menu` integration. This slot allows you to pass a `ui5-menu` instance that will be associated with the assistant.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"menu\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `HTMLElement`"
-        },
-        "valueStateMessage": {
-          "type": {
-            "name": "UI5WCSlotsNode"
-          },
-          "required": false,
-          "description": "Defines the value state message that will be displayed as pop up under the component.\nThe value state message slot should contain only one root element.\n\n**Note:** If not specified, a default text (in the respective language) will be displayed.\n\n**Note:** The `valueStateMessage` would be displayed if the component has\n`valueState` of type `Information`, `Critical` or `Negative`.\n\n__Note:__ The content of the prop will be rendered into a [&lt;slot&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot) by assigning the respective [slot](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/slot) attribute (`slot=\"valueStateMessage\"`).\nSince you can't change the DOM order of slots when declaring them within a prop, it might prove beneficial to manually mount them as part of the component's children, especially when facing problems with the reading order of screen readers.\n\n__Note:__ When passing a custom React component to this prop, you have to make sure your component reads the `slot` prop and appends it to the most outer element of your component.\nLearn more about it [here](https://ui5.github.io/webcomponents-react/v2/?path=/docs/knowledge-base-handling-slots--docs).\n\n__Supported Node Type/s:__ `Array<HTMLElement>`"
-        },
-        "onChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the text has changed and the focus leaves the component.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onInput": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TextAreaDomRef, TextAreaInputEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the value of the component changes at each keystroke or when\nsomething is pasted.\n\n**Note:** Call `event.preventDefault()` inside the handler of this event to prevent its default action/s.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ✅|✅|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "escapePressed",
-                "type": "boolean",
-                "description": "Indicates whether the Escape key was pressed, which triggers a revert to the previous value"
-              }
-            ],
-            "cancelable": true,
-            "bubbles": true
-          }
-        },
-        "onScroll": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when textarea is scrolled.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onSelect": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when some text has been selected.\n\n**Note:** Available since [v1.23.0](https://github.com/UI5/webcomponents/releases/tag/v1.23.0) of **@ui5/webcomponents-ai**.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|✅|",
-          "eventDetail": {
-            "params": [],
-            "cancelable": false,
-            "bubbles": true
-          }
-        },
-        "onStopGeneration": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TextAreaDomRef, never>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user requests to stop AI text generation.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|"
-        },
-        "onVersionChange": {
-          "type": {
-            "name": "(event: Ui5CustomEvent<TextAreaDomRef, TextAreaVersionChangeEventDetail>) => void"
-          },
-          "required": false,
-          "description": "Fired when the user clicks on version navigation buttons.\n\n| cancelable | bubbles |\n| :--------: | :-----: |\n| ❌|❌|",
-          "eventDetail": {
-            "params": [
-              {
-                "name": "backwards",
-                "type": "boolean",
-                "description": "Indicates if navigation is backwards (true) or forwards (false, default)."
-              }
-            ],
-            "cancelable": false,
-            "bubbles": false
-          }
-        },
-        "accessibleDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible description of the component.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-ai**."
-        },
-        "accessibleDescriptionRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that describe the textarea.\n\n**Note:** Available since [v2.16.0](https://github.com/UI5/webcomponents/releases/tag/v2.16.0) of **@ui5/webcomponents-ai**."
-        },
-        "accessibleName": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the accessible ARIA name of the component."
-        },
-        "accessibleNameRef": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Receives id(or many ids) of the elements that label the textarea."
-        },
-        "currentVersion": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Indicates the index of the currently displayed version.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "disabled": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Indicates whether the user can interact with the component or not.\n\n**Note:** A disabled component is completely noninteractive.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "growing": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Enables the component to automatically grow and shrink dynamically with its content.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "growingMaxRows": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the maximum number of rows that the component can grow.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "loading": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the `TextArea` is currently in a loading(processing) state.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "maxlength": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the maximum number of characters that the `value` can have."
-        },
-        "name": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Determines the name by which the component will be identified upon submission in an HTML form.\n\n**Note:** This property is only applicable within the context of an HTML Form element."
-        },
-        "placeholder": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines a short hint intended to aid the user with data entry when the component has no value."
-        },
-        "promptDescription": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the prompt description of the current action."
-        },
-        "readonly": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is read-only.\n\n**Note:** A read-only component is not editable,\nbut still provides visual feedback upon user interaction.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "required": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component is required.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "rows": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Defines the number of visible text rows for the component.\n\n**Notes:**\n\n- If the `growing` property is enabled, this property defines the minimum rows to be displayed\nin the textarea.\n- The CSS `height` property wins over the `rows` property, if both are set.",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "showExceededText": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Determines whether the characters exceeding the maximum allowed character count are visible\nin the component.\n\nIf set to `false`, the user is not allowed to enter more characters than what is set in the\n`maxlength` property.\nIf set to `true` the characters exceeding the `maxlength` value are selected on\npaste and the counter below the component displays their number.",
-          "defaultValue": {
-            "value": "false"
-          }
-        },
-        "totalVersions": {
-          "type": {
-            "name": "number"
-          },
-          "required": false,
-          "description": "Indicates the total number of result versions available.\n\nNotes:\nVersioning is hidden if the value is `0`",
-          "defaultValue": {
-            "value": "0"
-          }
-        },
-        "value": {
-          "type": {
-            "name": "string"
-          },
-          "required": false,
-          "description": "Defines the value of the component."
-        },
-        "valueState": {
-          "type": {
-            "name": "enum",
-            "raw": "ValueState | \"None\" | \"Positive\" | \"Critical\" | \"Negative\" | \"Information\"",
-            "value": [
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              },
-              {
-                "value": "\"None\""
-              },
-              {
-                "value": "\"Positive\""
-              },
-              {
-                "value": "\"Critical\""
-              },
-              {
-                "value": "\"Negative\""
-              },
-              {
-                "value": "\"Information\""
-              }
-            ]
-          },
-          "required": false,
-          "description": "Defines the value state of the component.\n\n**Note:** If `maxlength` property is set,\nthe component turns into \"Critical\" state once the characters exceeds the limit.\nIn this case, only the \"Negative\" state is considered and can be applied.",
-          "defaultValue": {
-            "value": "\"None\""
-          }
-        },
-        "waitForDefine": {
-          "type": {
-            "name": "boolean"
-          },
-          "required": false,
-          "description": "Defines whether the component should wait for the underlying custom element of the web component to be defined. This can be useful, for example, for using instance methods when mounting the component.\n\n__Note:__ This adds a rendering cycle to your component."
-        },
-        "ref": {
-          "type": {
-            "name": "Ref<TextAreaDomRef>"
-          },
-          "required": false,
-          "description": "Allows getting a ref to the component instance.\nOnce the component unmounts, React will set `ref.current` to `null`\n(or call the ref with `null` if you passed a callback ref).\n@see {@link https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom React Docs}"
-        },
-        "key": {
-          "type": {
-            "name": "Key"
-          },
-          "required": false,
-          "description": ""
-        }
-      },
-      "methods": [],
-      "cssParts": [
-        {
-          "name": "textarea",
-          "description": "Used to style the native textarea"
-        }
-      ]
-    }
-  },
-  "metadata": {
-    "version": "2.20.1",
-    "extractedAt": "2026-03-27T14:57:39.727Z",
-    "componentsCount": 26,
-    "webComponentsCount": 161,
-    "chartsCount": 12,
-    "aiCount": 5
-  }
-}
diff --git a/packages/mcp-server/src/tools/get_component_api/get_component_api.ts b/packages/mcp-server/src/tools/get_component_api/get_component_api.ts
index b9c6df35e9c..2a4b5a20b5d 100644
--- a/packages/mcp-server/src/tools/get_component_api/get_component_api.ts
+++ b/packages/mcp-server/src/tools/get_component_api/get_component_api.ts
@@ -111,7 +111,8 @@ EXAMPLE INPUT: { "componentName": "Dialog" }
   cssParts?: Array<{                   // CSS ::part() selectors for shadow DOM styling (web components only)
     name: string,                      // Use as: componentSelector::part(name) { ... }
     description: string
-  }>
+  }>,
+  subTypeDocs?: string                 // Markdown docs for complex prop types (e.g. column definition properties)
 }
 \`\`\`
 
@@ -132,6 +133,10 @@ EXAMPLE INPUT: { "componentName": "Dialog" }
       .array(z.object({ name: z.string(), description: z.string() }))
       .optional()
       .describe('CSS ::part() selectors for shadow DOM styling'),
+    subTypeDocs: z
+      .string()
+      .optional()
+      .describe('Additional documentation for complex prop types (e.g. AnalyticalTable column definition)'),
     _meta: z.object({
       apiVersion: z.string(),
       extractedAt: z.string().optional(),
diff --git a/packages/mcp-server/src/tools/list_components/descriptions.json b/packages/mcp-server/src/tools/list_components/descriptions.json
deleted file mode 100644
index c3ae313bebd..00000000000
--- a/packages/mcp-server/src/tools/list_components/descriptions.json
+++ /dev/null
@@ -1,834 +0,0 @@
-{
-  "components": {
-    "ActionSheet": {
-      "description": "The `ActionSheet` holds a list of buttons from which the user can select to complete an action.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "AnalyticalCardHeader": {
-      "description": "The `AnalyticalCardHeader` is a KPI header, enabling the AnalyticalCard representation.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "AnalyticalTable": {
-      "description": "The `AnalyticalTable` provides a set of convenient functions for responsive table design, including virtualization of rows and columns, infinite scrolling and customizable columns that will, unless otherwise defined, distribute the available space equally among themselves.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "FilterBar": {
-      "description": "The `FilterBar` displays filters in a user-friendly manner to populate values for a query.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "FilterGroupItem": {
-      "description": "Represents a filter belonging to the `FilterBar`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "FlexBox": {
-      "description": "The `FlexBox` builds the container for a flexible box layout by leveraging the CSS flexbox layout.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Grid": {
-      "description": "A layout container component used for aligning items with various sizes in a simple grid.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MessageBox": {
-      "description": "The `MessageBox` component provides easier methods to create a `Dialog`, such as standard alerts, confirmation dialogs, or arbitrary message dialogs.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MessageItem": {
-      "description": "A component used to hold different types of system messages inside the `MessageView` component.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MessageViewButton": {
-      "description": "The `MessageViewButton` can be used for opening a `Popover` containing the `MessageView` component.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Modals": {
-      "description": "Utility class for opening modals in an imperative way.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "NumericSideIndicator": {
-      "description": "Holds a set of side indicator attributes used in the AnalyticalCardHeader component.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ObjectPage": {
-      "description": "A component that allows apps to easily display information related to a business object.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ObjectPageAnchorBar": {
-      "description": "The `ObjectPageAnchorBar` bar contains the expand/collapse (expands or collapses the header content) and pin button (pins the content header).",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ObjectPageHeader": {
-      "description": "The `ObjectPageHeader` component is used to serve as header section of the `ObjectPage`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ObjectPageSection": {
-      "description": "Top-level information container of an `ObjectPage`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ObjectPageSubSection": {
-      "description": "Second-level information container of an `ObjectPage`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ObjectPageTitle": {
-      "description": "The `ObjectPageTitle` component is used to serve as title of the `ObjectPage`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ObjectStatus": {
-      "description": "Status information that can be either text with a value state, or an icon.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ResponsiveGridLayout": {
-      "description": "The Responsive Grid Layout positions UI elements in a multi-column flow layout.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SelectDialog": {
-      "description": "The SelectDialog enables users to filter a comprehensive list via a search field and to select one or more items.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SplitterElement": {
-      "description": "The `SplitterElement` holds the component of the content area.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SplitterLayout": {
-      "description": "A layout that contains several content areas.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ThemeProvider": {
-      "description": "In order to use `@ui5/webcomponents-react` you have to wrap your application's root component into the ThemeProvider.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "VariantItem": {
-      "description": "The `VariantItem` describes a variant/view of the `VariantManagement` component.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "VariantManagement": {
-      "description": "The VariantManagement can be used to manage variants (views).",
-      "package": "@ui5/webcomponents-react"
-    }
-  },
-  "webComponents": {
-    "Avatar": {
-      "description": "An image-like component that has different display options for representing images and icons in different shapes and sizes, depending on the use case....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "AvatarBadge": {
-      "description": "The `AvatarBadge` component is used to display a badge on top of `Avatar` component.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "AvatarGroup": {
-      "description": "Displays a group of avatars arranged horizontally.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Bar": {
-      "description": "The Bar is a container which is primarily used to hold titles, buttons and input elements and its design and functionality is the basis for page headers and footers.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "BarcodeScannerDialog": {
-      "description": "The `BarcodeScannerDialog` component provides barcode scanning functionality for all devices that support the `MediaDevices.getUserMedia()` native API.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Breadcrumbs": {
-      "description": "Enables users to navigate between items by providing a list of links to previous steps in the user's navigation path.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "BreadcrumbsItem": {
-      "description": "The `BreadcrumbsItem` component defines the content of an item in `Breadcrumbs`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "BusyIndicator": {
-      "description": "The `BusyIndicator` signals that some operation is going on and that the user must wait.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Button": {
-      "description": "The `Button` component represents a simple push button.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ButtonBadge": {
-      "description": "The `ButtonBadge` component defines a badge that appears in the `Button`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Calendar": {
-      "description": "The `Calendar` component allows users to select one or more dates....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "CalendarDate": {
-      "description": "The `Date` component defines a calendar date to be used inside `Calendar`...",
-      "package": "@ui5/webcomponents-react"
-    },
-    "CalendarDateRange": {
-      "description": "The `DateRange` component defines a range of dates to be used inside `Calendar`...",
-      "package": "@ui5/webcomponents-react"
-    },
-    "CalendarLegend": {
-      "description": "The `CalendarLegend` component is designed for use within the `Calendar` to display a legend.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "CalendarLegendItem": {
-      "description": "Each `CalendarLegendItem` represents a legend item, displaying a color with a label.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Card": {
-      "description": "The `Card` is a component that represents information in the form of a tile with separate header and content areas.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "CardHeader": {
-      "description": "The `CardHeader` is a component, meant to be used as a header of the `Card` component.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Carousel": {
-      "description": "The Carousel allows the user to browse through a set of items.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "CheckBox": {
-      "description": "Allows the user to set a binary value, such as true/false or yes/no for an item....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ColorPalette": {
-      "description": "The `ColorPalette` provides the users with a range of predefined colors.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ColorPaletteItem": {
-      "description": "The `ColorPaletteItem` component represents a color in the the `ColorPalette`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ColorPalettePopover": {
-      "description": "Represents a predefined range of colors for easier selection....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ColorPicker": {
-      "description": "The `ColorPicker` allows users to choose any color and provides different input options for selecting colors....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ComboBox": {
-      "description": "The `Combobox` component represents a drop-down menu with a list of the available options and a text input field to narrow down the options....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ComboBoxItem": {
-      "description": "The `CbItem` represents the item for a `Combobox`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ComboBoxItemGroup": {
-      "description": "The `CbGroupItem` is type of suggestion item, that can be used to split the `Combobox` suggestions into groups....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "DatePicker": {
-      "description": "The `DatePicker` component provides an input field with assigned calendar which opens on user action.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "DateRangePicker": {
-      "description": "The DateRangePicker enables the users to enter a localized date range using touch, mouse, keyboard input, or by selecting a date range in the calendar....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "DateTimePicker": {
-      "description": "The `DateTimePicker` component alows users to select both date (day, month and year) and time (hours, minutes and seconds) and for the purpose it consists of input field and Date/Time picker....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Dialog": {
-      "description": "The `Dialog` component is used to temporarily display some information in a size-limited window in front of the regular app screen.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "DynamicDateRange": {
-      "description": "The `DynamicDateRange` component provides a flexible interface to define date ranges using a combination of absolute dates, relative intervals, and preset ranges (e.g., \"Today\", \"Yesterday\", etc.).",
-      "package": "@ui5/webcomponents-react"
-    },
-    "DynamicPage": {
-      "description": "A layout component, representing a web page, consisting of a title, header with dynamic behavior, a content area, and an optional floating footer....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "DynamicPageHeader": {
-      "description": "Header of the DynamicPage....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "DynamicPageTitle": {
-      "description": "Title of the `DynamicPage`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "DynamicSideContent": {
-      "description": "The DynamicSideContent (`DynamicSideContent`) is a layout component that allows additional content to be displayed in a way that flexibly adapts to different screen sizes.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ExpandableText": {
-      "description": "The `ExpandableText` component allows displaying a large body of text in a small space.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "FileUploader": {
-      "description": "The `FileUploader` opens a file explorer dialog and enables users to upload files.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "FilterItem": {
-      "description": "The `FilterItem` component defines the filtering criteria for data in `ViewSettingsDialog`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "FilterItemOption": {
-      "description": "The `FilterItemOption` component defines individual filter values within a `FilterItem`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "FlexibleColumnLayout": {
-      "description": "The `FlexibleColumnLayout` implements the list-detail-detail paradigm by displaying up to three pages in separate columns.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Form": {
-      "description": "The Form is a layout component that arranges labels and form fields (like input fields) pairs into a specific number of columns....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "FormGroup": {
-      "description": "The FormGroup (FormGroup) represents a group inside the Form (Form) component and it consists of FormItem (FormItem) components....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "FormItem": {
-      "description": "The FormItem (FormItem) represents pair of a label and one or more components (text or text fields), associated to it....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "GroupItem": {
-      "description": "The `GroupItem` component defines the grouping criteria for data in `ViewSettingsDialog`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Icon": {
-      "description": "The `Icon` component represents an SVG icon.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "IllustratedMessage": {
-      "description": "An IllustratedMessage is a recommended combination of a solution-oriented message, an engaging illustration, and conversational tone to better communicate an empty or a success state than just show a ...",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Input": {
-      "description": "The `Input` component allows the user to enter and edit text or numeric values in one line....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Label": {
-      "description": "The `Label` is a component used to represent a label for elements like input, textarea, select.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Link": {
-      "description": "The `Link` is a hyperlink component that is used to navigate to other apps and web pages, or to trigger actions.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "List": {
-      "description": "The `List` component allows displaying a list of items, advanced keyboard handling support for navigating between items, and predefined modes to improve the development efficiency....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ListItemCustom": {
-      "description": "A component to be used as custom list item within the `List` the same way as the standard `Li`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ListItemGroup": {
-      "description": "The `LiGroup` is a special list item, used only to create groups of list items....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ListItemStandard": {
-      "description": "The `Li` represents the simplest type of item for a `List`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MediaGallery": {
-      "description": "The `MediaGallery` component allows the user to browse through multimedia items.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MediaGalleryItem": {
-      "description": "The `MediaGalleryItem` web component represents the items displayed in the `MediaGallery` web component....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Menu": {
-      "description": "`Menu` component represents a hierarchical menu structure....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MenuItem": {
-      "description": "`MenuItem` is the item to use inside a `Menu`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MenuItemGroup": {
-      "description": "The `MenuItemGroup` component represents a group of items designed for use inside a `Menu`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MenuSeparator": {
-      "description": "The `MenuSeparator` represents a horizontal line to separate menu items inside a `Menu`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MessageStrip": {
-      "description": "The MessageStrip component allows for the embedding of application-related messages.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MultiComboBox": {
-      "description": "The `MultiCombobox` component consists of a list box with items and a text field allowing the user to either type a value directly into the text field, or choose from the list of existing items....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MultiComboBoxItem": {
-      "description": "The `McbItem` represents the item for a `MultiCombobox`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MultiComboBoxItemGroup": {
-      "description": "The `McbItemGroup` is type of suggestion item, that can be used to split the `MultiCombobox` suggestions into groups....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "MultiInput": {
-      "description": "A `MultiInput` field allows the user to enter multiple values, which are displayed as `Token`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "NavigationLayout": {
-      "description": "The `NavigationLayout` is a container component that can be used to create a layout with a header, a side navigation and a content area....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "NotificationList": {
-      "description": "The `NotificationList` web component represents a container for `LiNotificationGroup` and `LiNotification`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "NotificationListGroupItem": {
-      "description": "The `LiNotificationGroup` is a special type of list item, that unlike others can group items within self, usually `LiNotification` items....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "NotificationListItem": {
-      "description": "The `LiNotification` is a type of list item, meant to display notifications....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Option": {
-      "description": "The `Option` component defines the content of an option in the `Select`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "OptionCustom": {
-      "description": "The `OptionCustom` component defines a custom content of an option in the `Select`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Page": {
-      "description": "The `Page` is a container component that holds one whole screen of an application.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Panel": {
-      "description": "The `Panel` component is a container which has a header and a content area and is used for grouping and displaying information.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Popover": {
-      "description": "The `Popover` component displays additional information for an object in a compact way and without leaving the page.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ProductSwitch": {
-      "description": "The `ProductSwitch` is an SAP Fiori specific web component that is used in `Shellbar` and allows the user to easily switch between products....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ProductSwitchItem": {
-      "description": "The `ProductSwitchItem` web component represents the items displayed in the `ProductSwitch` web component....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ProgressIndicator": {
-      "description": "Shows the progress of a process in a graphical way.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "RadioButton": {
-      "description": "The `RadioButton` component enables users to select a single option from a set of options.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "RangeSlider": {
-      "description": "Represents a numerical interval and two handles (grips) to select a sub-range within it.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "RatingIndicator": {
-      "description": "The Rating Indicator is used to display a specific number of icons that are used to rate an item.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ResponsivePopover": {
-      "description": "The `ResponsivePopover` acts as a Popover on desktop and tablet, while on phone it acts as a Dialog.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Search": {
-      "description": "A `Search` is an input with suggestions, used for user search....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SearchItem": {
-      "description": "A `SearchItem` is a list item, used for displaying search suggestions...",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SearchItemGroup": {
-      "description": "The `SearchItemGroup` is type of suggestion item, that can be used to split the `SearchItem` suggestions into groups....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SearchItemShowMore": {
-      "description": "A `SearchItemShowMore` is a special type of Li that acts as a button to progressively reveal additional (overflow) items within a group....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SearchMessageArea": {
-      "description": "`import \"@ui5/webcomponents-fiori/dist/SearchMessageArea.js\";`...",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SearchScope": {
-      "description": "The `SearchScope` represents the options for the scope in `Search`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SegmentedButton": {
-      "description": "The `SegmentedButton` shows a group of items.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SegmentedButtonItem": {
-      "description": "Users can use the `SegmentedButtonItem` as part of a `SegmentedButton`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Select": {
-      "description": "The `Select` component is used to create a drop-down list....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ShellBar": {
-      "description": "The `Shellbar` is meant to serve as an application header and includes numerous built-in features, such as: logo, profile image/icon, title, search field, notifications and so on....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ShellBarBranding": {
-      "description": "The `ShellbarBranding` component is intended to be placed inside the branding slot of the `Shellbar` component.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ShellBarItem": {
-      "description": "The `ShellbarItem` represents a custom item for `Shellbar`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ShellBarSearch": {
-      "description": "Search field for the ShellBar component....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ShellBarSpacer": {
-      "description": "The `ShellbarSpacer` is an element, used for visual separation between the two content parts of the `Shellbar`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SideNavigation": {
-      "description": "The `SideNavigation` is used as a standard menu in applications.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SideNavigationGroup": {
-      "description": "Represents a group of navigation actions within `SideNavigation`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SideNavigationItem": {
-      "description": "Represents a navigation action.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SideNavigationSubItem": {
-      "description": "Represents a single navigation action within `SideNavigationItem`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Slider": {
-      "description": "The Slider component represents a numerical range and a handle (grip).",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SortItem": {
-      "description": "The `SortItem` component defines the sorting criteria for data in `ViewSettingsDialog`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SpecialCalendarDate": {
-      "description": "The `SpecialDate` component defines a special calendar date to be used inside `Calendar`, which is visually distinguished from the rest of the dates....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SplitButton": {
-      "description": "`SplitButton` enables users to trigger actions.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "StepInput": {
-      "description": "The `StepInput` consists of an input field and buttons with icons to increase/decrease the value with the predefined step....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SuggestionItem": {
-      "description": "The `SuggestionItem` represents the suggestion item of the `Input`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SuggestionItemCustom": {
-      "description": "The `SuggestionItemCustom` is type of suggestion item, that can be used to place suggestion items with custom content in the input.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "SuggestionItemGroup": {
-      "description": "The `SuggestionItemGroup` is type of suggestion item, that can be used to split the `Input` suggestions into groups....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Switch": {
-      "description": "The `Switch` component is used for changing between binary states....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Tab": {
-      "description": "The `Tab` represents a selectable item inside a `Tabcontainer`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TabContainer": {
-      "description": "The `Tabcontainer` represents a collection of tabs with associated content.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TabSeparator": {
-      "description": "The `TabSeparator` represents a vertical line to separate tabs inside a `Tabcontainer`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Table": {
-      "description": "The `Table` component provides a set of sophisticated features for displaying and dealing with vast amounts of data in a responsive manner.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableCell": {
-      "description": "The `TableCell` represents a cell inside of a `Table`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableGrowing": {
-      "description": "The `TableGrowing` component is used inside the `Table` to add a growing/data loading functionalities to the table....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableHeaderCell": {
-      "description": "The `TableHeaderCell` component represents a column in the `Table`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableHeaderCellActionAI": {
-      "description": "The `TableHeaderCellActionAi` component defines a dedicated AI action for the table column....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableHeaderRow": {
-      "description": "The `TableHeaderRow` component represents the table headers of a `Table`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableRow": {
-      "description": "The `TableRow` component represents a row in the `Table`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableRowAction": {
-      "description": "The `TableRowAction` component defines an action for table rows....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableRowActionNavigation": {
-      "description": "The `TableRowActionNavigation` component defines a navigation action for table rows....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableSelection": {
-      "description": "The `TableSelection` component is used inside the `Table` to add key-based selection capabilities to the `Table`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableSelectionMulti": {
-      "description": "The `TableSelectionMulti` component is used inside the `Table` to add multi-selection capabilities to the `Table`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableSelectionSingle": {
-      "description": "The `TableSelectionSingle` component is used inside the `Table` to add single selection capabilities to the `Table`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TableVirtualizer": {
-      "description": "The `TableVirtualizer` component is used inside the `Table` to virtualize the table rows, if the `overflowMode` property of the table is set to 'Scroll'.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Tag": {
-      "description": "The `Tag` is a component which serves the purpose to attract the user attention to some piece of information (state, quantity, condition, etc.).",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Text": {
-      "description": "The `Text` component displays text that can be used in any content area of an application....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TextArea": {
-      "description": "The `Textarea` component is used to enter multiple rows of text....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TimePicker": {
-      "description": "The `TimePicker` component provides an input field with assigned clocks which are opened on user action.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Timeline": {
-      "description": "The `Timeline` component shows entries (such as objects, events, or posts) in chronological order.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TimelineGroupItem": {
-      "description": "An entry posted on the timeline.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TimelineItem": {
-      "description": "An entry posted on the timeline....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Title": {
-      "description": "The `Title` component is used to display titles inside a page.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Toast": {
-      "description": "The `Toast` is a small, non-disruptive popup for success or information messages that disappears automatically after a few seconds....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ToggleButton": {
-      "description": "The `ToggleButton` component is an enhanced `Button` that can be toggled between pressed and normal states.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Token": {
-      "description": "Tokens are small items of information (similar to tags) that mainly serve to visualize previously selected items....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Tokenizer": {
-      "description": "A `Tokenizer` is an invisible container for `Token`s that supports keyboard navigation and token selection....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Toolbar": {
-      "description": "The `Toolbar` component is used to create a horizontal layout with items.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ToolbarButton": {
-      "description": "The `ToolbarButton` represents an abstract action, used in the `Toolbar`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ToolbarItem": {
-      "description": "The `ToolbarItem` is a wrapper component used to integrate UI5 Web Components into the `Toolbar`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ToolbarSelect": {
-      "description": "The `ToolbarSelect` component is used to create a toolbar drop-down list.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ToolbarSelectOption": {
-      "description": "The `ToolbarSelectOption` component defines the content of an option in the `ToolbarSelect`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ToolbarSeparator": {
-      "description": "The `ToolbarSeparator` is an element, used for visual separation between two elements.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ToolbarSpacer": {
-      "description": "The `ToolbarSpacer` is an element, used for taking needed space for toolbar items to take 100% width.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Tree": {
-      "description": "The `Tree` component provides a tree structure for displaying data in a hierarchy....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TreeItem": {
-      "description": "The `TreeItem` represents a node in a tree structure, shown as a `List`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "TreeItemCustom": {
-      "description": "The `TreeItemCustom` represents a node in a tree structure, shown as a `List`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UploadCollection": {
-      "description": "This component allows you to represent files before uploading them to a server, with the help of `UploadCollectionItem`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UploadCollectionItem": {
-      "description": "A component to be used within the `UploadCollection`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UserMenu": {
-      "description": "The `UserMenu` is an SAP Fiori specific web component that is used in `Shellbar` and allows the user to easily see information and settings for the current user and all other logged in accounts....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UserMenuAccount": {
-      "description": "The `UserMenuAccount` represents an account in the `UserMenu`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UserMenuItem": {
-      "description": "`UserMenuItem` is the item to use inside a `UserMenu`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UserMenuItemGroup": {
-      "description": "The `UserMenuItemGroup` component represents a group of items designed for use inside a `UserMenu`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UserSettingsAccountView": {
-      "description": "The `UserSettingsAccountView` represents a view displayed in the `UserSettingsItem`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UserSettingsAppearanceView": {
-      "description": "The `UserSettingsAppearanceView` represents a view displayed in the `UserSettingsItem`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UserSettingsAppearanceViewGroup": {
-      "description": "The `UserSettingsAppearanceViewGroup` is a special list item group used to group appearance view items....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UserSettingsAppearanceViewItem": {
-      "description": "The `UserSettingsAppearanceViewItem` represents a theme/appearance option item within the `UserSettingsAppearanceView`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UserSettingsDialog": {
-      "description": "The `UserSettingsDialog` is an SAP Fiori-specific web component used in the `UserMenu`.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UserSettingsItem": {
-      "description": "The `UserSettingsItem` represents an item in the `UserSettingsDialog`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "UserSettingsView": {
-      "description": "The `UserSettingsView` represents a view displayed in the `UserSettingsItem`....",
-      "package": "@ui5/webcomponents-react"
-    },
-    "ViewSettingsDialog": {
-      "description": "The `ViewSettingsDialog` component helps the user to sort data within a list or a table.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "Wizard": {
-      "description": "The `Wizard` helps users to complete a complex task by dividing it into sections and guiding them through it.",
-      "package": "@ui5/webcomponents-react"
-    },
-    "WizardStep": {
-      "description": "A component that represents a logical step as part of the `Wizard`.",
-      "package": "@ui5/webcomponents-react"
-    }
-  },
-  "charts": {
-    "BarChart": {
-      "description": "A `BarChart` is a data visualization where each category is represented by a rectangle, with the width of the rectangle being proportional to the values being plotted.",
-      "package": "@ui5/webcomponents-react-charts"
-    },
-    "BulletChart": {
-      "description": "The `BulletChart` is used to compare primary and secondary (comparison) values.",
-      "package": "@ui5/webcomponents-react-charts"
-    },
-    "ColumnChart": {
-      "description": "A `ColumnChart` is a data visualization where each category is represented by a rectangle, with the height of the rectangle being proportional to the values being plotted.",
-      "package": "@ui5/webcomponents-react-charts"
-    },
-    "ColumnChartWithTrend": {
-      "description": "A `ColumnChartWithTrend` is a data visualization where each category is represented by a rectangle, with the height of the rectangle being proportional to the values being plotted amd a trend line...",
-      "package": "@ui5/webcomponents-react-charts"
-    },
-    "ComposedChart": {
-      "description": "The `ComposedChart` enables you to combine different chart types in one chart, e.g.",
-      "package": "@ui5/webcomponents-react-charts"
-    },
-    "DonutChart": {
-      "description": "A `DonutChart` is a type of graph that displays data in a circular graph with a cut-out hole in the middle.",
-      "package": "@ui5/webcomponents-react-charts"
-    },
-    "LineChart": {
-      "description": "A `LineChart` is a type of chart used to show information that changes over time - it connects multiple dots.",
-      "package": "@ui5/webcomponents-react-charts"
-    },
-    "PieChart": {
-      "description": "A Pie Chart is a type of graph that displays data in a circular graph.",
-      "package": "@ui5/webcomponents-react-charts"
-    },
-    "RadarChart": {
-      "description": "A radar or spider or web chart is a two-dimensional chart type designed to plot one or more series of values over multiple quantitative variables.",
-      "package": "@ui5/webcomponents-react-charts"
-    },
-    "RadialChart": {
-      "description": "Displays a ring chart highlighting a current status.",
-      "package": "@ui5/webcomponents-react-charts"
-    },
-    "ScatterChart": {
-      "description": "A `ScatterChart` is a data visualization that displays multiple circles (bubbles) in a two-dimensional plot.",
-      "package": "@ui5/webcomponents-react-charts"
-    },
-    "TimelineChart": {
-      "description": "> __Experimental Component!__ <br /> A `TimelineChart` is a data visualization chart that can be used to represent Gantt charts or any other timeline-based visualizations.",
-      "package": "@ui5/webcomponents-react-charts"
-    }
-  },
-  "ai": {
-    "Button": {
-      "description": "The `Button` component serves as a button for AI-related scenarios.",
-      "package": "@ui5/webcomponents-ai-react"
-    },
-    "ButtonState": {
-      "description": "`ButtonState` is the item to use for defining states of `Button` components....",
-      "package": "@ui5/webcomponents-ai-react"
-    },
-    "Input": {
-      "description": "The `Input` component extends the standard `Input` with **AI Writing Assistant** capabilities....",
-      "package": "@ui5/webcomponents-ai-react"
-    },
-    "PromptInput": {
-      "description": "The `PromptInput` component allows the user to write custom instructions in natural language, so that AI is guided to generate content tailored to user needs....",
-      "package": "@ui5/webcomponents-ai-react"
-    },
-    "TextArea": {
-      "description": "The `Textarea` component extends the standard TextArea with Writing Assistant capabilities.",
-      "package": "@ui5/webcomponents-ai-react"
-    }
-  },
-  "metadata": {
-    "version": "2.20.1",
-    "extractedAt": "2026-03-27T14:57:39.727Z",
-    "componentsCount": 26,
-    "webComponentsCount": 161,
-    "chartsCount": 12,
-    "aiCount": 5
-  }
-}
diff --git a/packages/mcp-server/src/types/component-api.ts b/packages/mcp-server/src/types/component-api.ts
index 3e4c8ddc07e..595d4f74e58 100644
--- a/packages/mcp-server/src/types/component-api.ts
+++ b/packages/mcp-server/src/types/component-api.ts
@@ -57,6 +57,8 @@ export interface ComponentApiData {
   props: Record<string, CleanedProp>;
   methods: MethodInfo[];
   cssParts?: CssPart[];
+  /** Additional documentation for complex prop types (e.g. column definition shape). */
+  subTypeDocs?: string;
 }
 
 export interface ComponentDescription {

From c71146dcabf70eb85470420d67398ade54f8570a Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Mon, 30 Mar 2026 11:01:56 +0200
Subject: [PATCH 07/16] Fetch Form ui5wc docs

---
 .../scripts/extract-component-descriptions.ts        | 12 ++++++++++++
 .../src/tools/get_component_api/get_component_api.ts |  5 +++++
 packages/mcp-server/src/types/component-api.ts       |  2 ++
 3 files changed, 19 insertions(+)

diff --git a/packages/mcp-server/scripts/extract-component-descriptions.ts b/packages/mcp-server/scripts/extract-component-descriptions.ts
index 5fc81765dac..f180aae7e41 100644
--- a/packages/mcp-server/scripts/extract-component-descriptions.ts
+++ b/packages/mcp-server/scripts/extract-component-descriptions.ts
@@ -138,6 +138,18 @@ async function main() {
     }
   }
 
+  // --- Upstream documentation links (for components with complex behavioral logic) ---
+  const upstreamDocUrls = new Map<string, string>([['Form', 'https://ui5.github.io/webcomponents/components/Form/']]);
+  for (const [componentName, docUrl] of upstreamDocUrls) {
+    for (const category of ['components', 'webComponents', 'charts', 'ai'] as const) {
+      if (componentApis[category][componentName]) {
+        componentApis[category][componentName].docUrl = docUrl;
+        console.log(`Attached docUrl for ${componentName}`);
+        break;
+      }
+    }
+  }
+
   // --- Metadata ---
   try {
     const wcrPkg = JSON.parse(readFileSync(join(UI5_WCR_PATH, 'packages/main/package.json'), 'utf-8'));
diff --git a/packages/mcp-server/src/tools/get_component_api/get_component_api.ts b/packages/mcp-server/src/tools/get_component_api/get_component_api.ts
index 2a4b5a20b5d..2f5078e54c3 100644
--- a/packages/mcp-server/src/tools/get_component_api/get_component_api.ts
+++ b/packages/mcp-server/src/tools/get_component_api/get_component_api.ts
@@ -113,6 +113,7 @@ EXAMPLE INPUT: { "componentName": "Dialog" }
     description: string
   }>,
   subTypeDocs?: string                 // Markdown docs for complex prop types (e.g. column definition properties)
+  docUrl?: string                      // Upstream docs link for complex behavioral concepts
 }
 \`\`\`
 
@@ -137,6 +138,10 @@ EXAMPLE INPUT: { "componentName": "Dialog" }
       .string()
       .optional()
       .describe('Additional documentation for complex prop types (e.g. AnalyticalTable column definition)'),
+    docUrl: z
+      .string()
+      .optional()
+      .describe('Link to upstream documentation for complex behavioral concepts (e.g. layout algorithms)'),
     _meta: z.object({
       apiVersion: z.string(),
       extractedAt: z.string().optional(),
diff --git a/packages/mcp-server/src/types/component-api.ts b/packages/mcp-server/src/types/component-api.ts
index 595d4f74e58..ebbabb9d2c2 100644
--- a/packages/mcp-server/src/types/component-api.ts
+++ b/packages/mcp-server/src/types/component-api.ts
@@ -59,6 +59,8 @@ export interface ComponentApiData {
   cssParts?: CssPart[];
   /** Additional documentation for complex prop types (e.g. column definition shape). */
   subTypeDocs?: string;
+  /** Link to upstream UI5 Web Components documentation for complex behavioral concepts. */
+  docUrl?: string;
 }
 
 export interface ComponentDescription {

From d5dbc004ace4b76f223878b6b8e87f36f6e2887c Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Mon, 30 Mar 2026 11:21:54 +0200
Subject: [PATCH 08/16] refactor: consolidate manual config into
 `component-config.ts`

---
 .../scripts/extract-component-descriptions.ts | 14 ++++-----
 .../tools/list_components/list_components.ts  | 10 ++++---
 .../{categories.ts => component-config.ts}    | 30 ++++++++++++++++++-
 3 files changed, 41 insertions(+), 13 deletions(-)
 rename packages/mcp-server/src/utils/{categories.ts => component-config.ts} (80%)

diff --git a/packages/mcp-server/scripts/extract-component-descriptions.ts b/packages/mcp-server/scripts/extract-component-descriptions.ts
index f180aae7e41..9174c0a0b51 100644
--- a/packages/mcp-server/scripts/extract-component-descriptions.ts
+++ b/packages/mcp-server/scripts/extract-component-descriptions.ts
@@ -21,7 +21,9 @@ import {
   WEB_COMPONENT_CATEGORIES,
   CHART_CATEGORIES,
   AI_CATEGORIES,
-} from '../src/utils/categories.js';
+  SUB_TYPE_DOCS,
+  UPSTREAM_DOC_URLS,
+} from '../src/utils/component-config.js';
 import { findComponentCategory } from './utils/text.js';
 import { extractFullComponentApi } from './utils/docgen.js';
 import { loadCemData, enrichWithCem } from './utils/cem.js';
@@ -120,15 +122,12 @@ async function main() {
   }
 
   // --- Sub-type documentation (complex prop types) ---
-  const subTypeDocsMap: Record<string, string> = {
-    AnalyticalTable: join(UI5_WCR_PATH, 'packages/main/src/components/AnalyticalTable/docs/ColumnProperties.md'),
-  };
-  for (const [componentName, mdPath] of Object.entries(subTypeDocsMap)) {
+  for (const [componentName, relativePath] of Object.entries(SUB_TYPE_DOCS)) {
+    const mdPath = join(UI5_WCR_PATH, relativePath);
     if (!existsSync(mdPath)) {
       console.warn(`  subTypeDocs not found: ${mdPath}`);
       continue;
     }
-    // Find the component in any category
     for (const category of ['components', 'webComponents', 'charts', 'ai'] as const) {
       if (componentApis[category][componentName]) {
         componentApis[category][componentName].subTypeDocs = readFileSync(mdPath, 'utf-8');
@@ -139,8 +138,7 @@ async function main() {
   }
 
   // --- Upstream documentation links (for components with complex behavioral logic) ---
-  const upstreamDocUrls = new Map<string, string>([['Form', 'https://ui5.github.io/webcomponents/components/Form/']]);
-  for (const [componentName, docUrl] of upstreamDocUrls) {
+  for (const [componentName, docUrl] of UPSTREAM_DOC_URLS) {
     for (const category of ['components', 'webComponents', 'charts', 'ai'] as const) {
       if (componentApis[category][componentName]) {
         componentApis[category][componentName].docUrl = docUrl;
diff --git a/packages/mcp-server/src/tools/list_components/list_components.ts b/packages/mcp-server/src/tools/list_components/list_components.ts
index d661d6e772d..26c85f65cf1 100644
--- a/packages/mcp-server/src/tools/list_components/list_components.ts
+++ b/packages/mcp-server/src/tools/list_components/list_components.ts
@@ -12,7 +12,9 @@ import {
   WEB_COMPONENT_CATEGORIES,
   CHART_CATEGORIES,
   AI_CATEGORIES,
-} from '../../utils/categories.js';
+  MAIN_CATEGORY_NAMES,
+  TOTAL_COMPONENT_COUNT,
+} from '../../utils/component-config.js';
 import { createTextResponse, handleToolError } from '../../utils/index.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -61,7 +63,7 @@ function formatComponentList(categoryFilter?: string, packageFilter?: string): s
     output += '## @ui5/webcomponents-react\n\n';
 
     // Combine React and Web Component categories
-    const allCategories = ['Data Display', 'Layouts & Floorplans', 'Inputs', 'Modals & Popovers', 'User Feedback'];
+    const allCategories = MAIN_CATEGORY_NAMES;
 
     for (const category of allCategories) {
       if (categoryFilter && categoryFilter !== category && categoryFilter !== WEB_COMPONENTS_CATEGORY) continue;
@@ -158,10 +160,10 @@ export const listComponentsTool = {
     openWorldHint: false,
   },
   description:
-    'Browse all 203 available UI5 Web Components for React components across 4 packages with descriptions, categories, and import statements.\n\n' +
+    `Browse all ${TOTAL_COMPONENT_COUNT} available UI5 Web Components for React components across 4 packages with descriptions, categories, and import statements.\n\n` +
     'WHEN TO USE: You need to discover which components exist, find the right component for a use case, or verify a component name before calling get_component_api.\n' +
     'DO NOT USE FOR: Getting detailed props or methods — use get_component_api after finding the component name here.\n' +
-    'LIMITS: Returns all matching components at once (up to 203). Filter by category or package to reduce output size.\n\n' +
+    `LIMITS: Returns all matching components at once (up to ${TOTAL_COMPONENT_COUNT}). Filter by category or package to reduce output size.\n\n` +
     'EXAMPLE INPUT: { "category": "Inputs" }\n' +
     'EXAMPLE INPUT: { "package": "@ui5/webcomponents-react-charts" }\n' +
     'EXAMPLE INPUT: {} (returns all components)',
diff --git a/packages/mcp-server/src/utils/categories.ts b/packages/mcp-server/src/utils/component-config.ts
similarity index 80%
rename from packages/mcp-server/src/utils/categories.ts
rename to packages/mcp-server/src/utils/component-config.ts
index 0cab64dcd32..5b0bbf5a96d 100644
--- a/packages/mcp-server/src/utils/categories.ts
+++ b/packages/mcp-server/src/utils/component-config.ts
@@ -1,7 +1,12 @@
 /**
- * Component categorization shared between list_components and extraction script
+ * Single source of truth for all manually maintained component data.
+ * Update this file when components are added/removed or enrichment config changes.
+ *
+ * New components not listed here will trigger a warning in `npm run extract:descriptions`.
  */
 
+// --- Component Categories ---
+
 export const REACT_COMPONENT_CATEGORIES = {
   'Data Display': ['AnalyticalTable', 'AnalyticalCardHeader', 'ObjectStatus', 'NumericSideIndicator'],
   'Layouts & Floorplans': [
@@ -216,3 +221,26 @@ export const CHART_CATEGORIES = {
 export const AI_CATEGORIES = {
   'AI Components': ['Button', 'ButtonState', 'Input', 'PromptInput', 'TextArea'],
 };
+
+// --- Derived (computed from categories) ---
+
+export const MAIN_CATEGORY_NAMES = Object.keys(REACT_COMPONENT_CATEGORIES);
+
+export const TOTAL_COMPONENT_COUNT = [
+  REACT_COMPONENT_CATEGORIES,
+  WEB_COMPONENT_CATEGORIES,
+  CHART_CATEGORIES,
+  AI_CATEGORIES,
+].reduce((sum, cats) => sum + Object.values(cats).reduce((s, arr) => s + arr.length, 0), 0);
+
+// --- Enrichment Config ---
+
+/** Complex prop types that need additional markdown docs. Path relative to monorepo root. */
+export const SUB_TYPE_DOCS: Record<string, string> = {
+  AnalyticalTable: 'packages/main/src/components/AnalyticalTable/docs/ColumnProperties.md',
+};
+
+/** Upstream doc links for components with complex behavioral logic not captured in props. */
+export const UPSTREAM_DOC_URLS = new Map<string, string>([
+  ['Form', 'https://ui5.github.io/webcomponents/components/Form/'],
+]);

From fda0534498f9f42da4a2f5ab3ef374c7aaea81d5 Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Mon, 30 Mar 2026 11:46:15 +0200
Subject: [PATCH 09/16] replace prompt with tool to create new ui5wcr app

---
 packages/mcp-server/src/index.ts              |   5 -
 packages/mcp-server/src/prompts/create-app.ts | 117 -----------------
 .../src/tools/create_app/create_app.ts        | 118 ++++++++++++++++++
 packages/mcp-server/src/tools/index.ts        |   1 +
 4 files changed, 119 insertions(+), 122 deletions(-)
 delete mode 100644 packages/mcp-server/src/prompts/create-app.ts
 create mode 100644 packages/mcp-server/src/tools/create_app/create_app.ts

diff --git a/packages/mcp-server/src/index.ts b/packages/mcp-server/src/index.ts
index 78fdbf6541d..879801a3346 100644
--- a/packages/mcp-server/src/index.ts
+++ b/packages/mcp-server/src/index.ts
@@ -11,7 +11,6 @@ import { fileURLToPath } from 'url';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { logger } from './logger.js';
-import { createAppPrompt } from './prompts/create-app.js';
 import * as tools from './tools/index.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -66,10 +65,6 @@ server.registerResource(
 );
 logger.info('Registered llms.txt resource');
 
-// Register prompts
-server.registerPrompt(createAppPrompt.name, createAppPrompt.config, createAppPrompt.callback);
-logger.info('Registered create-app prompt');
-
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
diff --git a/packages/mcp-server/src/prompts/create-app.ts b/packages/mcp-server/src/prompts/create-app.ts
deleted file mode 100644
index 670ff71038a..00000000000
--- a/packages/mcp-server/src/prompts/create-app.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-/**
- * @fileoverview create-app MCP prompt
- * Scaffolds a new UI5 Web Components for React application from an official template.
- */
-
-import { readFileSync } from 'node:fs';
-import { join, dirname, basename } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { z } from 'zod';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const REPO = 'UI5/webcomponents-react';
-
-interface ProjectTemplate {
-  name: string;
-  variant?: string;
-  framework: string;
-  type: 'template' | 'example';
-  path: string;
-  typescript?: boolean;
-  stackBlitz?: string;
-}
-
-// Load templates at module init — filters for type: "template" only
-let templates: ProjectTemplate[] = [];
-try {
-  const templatesPath = join(__dirname, '..', 'docs', 'project-templates.json');
-  const all: ProjectTemplate[] = JSON.parse(readFileSync(templatesPath, 'utf-8'));
-  templates = all.filter((t) => t.type === 'template');
-} catch {
-  // Bundled JSON not available — prompt will report no templates
-}
-
-/** Derive a short ID from the template path, e.g. "templates/nextjs-app" → "nextjs-app" */
-function templateId(t: ProjectTemplate): string {
-  return basename(t.path);
-}
-
-function templateLabel(t: ProjectTemplate): string {
-  return t.variant ? `${t.name} (${t.variant})` : t.name;
-}
-
-const availableIds = templates.map(templateId);
-const availableList = templates.map((t) => `- \`${templateId(t)}\` — ${templateLabel(t)}`).join('\n');
-
-export const createAppPrompt = {
-  name: 'create-app',
-  config: {
-    title: 'Create App',
-    description:
-      'Scaffold a new UI5 Web Components for React application from an official template using degit.\n\n' +
-      `Available templates:\n${availableList}`,
-    argsSchema: {
-      template: z.string().describe(`Template to use. Available: ${availableIds.join(', ')}`),
-      appName: z.string().describe('Name for the new application directory'),
-    },
-  },
-  callback: ({ template, appName }: { template: string; appName: string }) => {
-    const entry = templates.find((t) => templateId(t) === template);
-
-    if (!entry) {
-      return {
-        messages: [
-          {
-            role: 'user' as const,
-            content: {
-              type: 'text' as const,
-              text: `Unknown template "${template}".\n\n` + `Available templates:\n${availableList}`,
-            },
-          },
-        ],
-      };
-    }
-
-    const label = templateLabel(entry);
-    const degitCmd = `npx degit ${REPO}/${entry.path}#main ${appName}`;
-
-    const text = [
-      `Scaffold a new **${label}** application called \`${appName}\`.`,
-      '',
-      '## Steps',
-      '',
-      `1. Run: \`${degitCmd}\``,
-      `2. \`cd ${appName}\``,
-      `3. Update the \`name\` field in \`package.json\` to \`"${appName}"\``,
-      '4. Run: `npm install`',
-      '5. Start the dev server: `npm run dev`',
-      '',
-      '## Template Details',
-      '',
-      `- **Framework**: ${entry.name}${entry.variant ? ` (${entry.variant})` : ''}`,
-      `- **Language**: ${entry.typescript ? 'TypeScript' : 'JavaScript'}`,
-      `- **GitHub**: https://github.com/${REPO}/tree/main/${entry.path}`,
-      entry.stackBlitz ? `- **StackBlitz**: ${entry.stackBlitz}` : '',
-      '',
-      '## Post-Setup',
-      '',
-      '- ThemeProvider from `@ui5/webcomponents-react` is already configured in the template',
-      "- Import components: `import { Button, Input, Card } from '@ui5/webcomponents-react'`",
-      '- Use `get_component_api` to look up component props, events, and methods',
-      '- Use `get_documentation` for guides on styling, i18n, SSR, and more',
-    ]
-      .filter(Boolean)
-      .join('\n');
-
-    return {
-      messages: [
-        {
-          role: 'user' as const,
-          content: { type: 'text' as const, text },
-        },
-      ],
-    };
-  },
-};
diff --git a/packages/mcp-server/src/tools/create_app/create_app.ts b/packages/mcp-server/src/tools/create_app/create_app.ts
new file mode 100644
index 00000000000..6d00091dc99
--- /dev/null
+++ b/packages/mcp-server/src/tools/create_app/create_app.ts
@@ -0,0 +1,118 @@
+/**
+ * @fileOverview create_app tool
+ * Scaffolds a new UI5 Web Components for React application from an official template.
+ */
+
+import { readFileSync } from 'node:fs';
+import { join, dirname, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { z } from 'zod';
+import { createTextResponse, handleToolError } from '../../utils/index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const REPO = 'UI5/webcomponents-react';
+
+interface ProjectTemplate {
+  name: string;
+  variant?: string;
+  framework: string;
+  type: 'template' | 'example';
+  path: string;
+  typescript?: boolean;
+  stackBlitz?: string;
+}
+
+let templates: ProjectTemplate[] = [];
+try {
+  const templatesPath = join(__dirname, '../../../docs/project-templates.json');
+  const all: ProjectTemplate[] = JSON.parse(readFileSync(templatesPath, 'utf-8'));
+  templates = all.filter((t) => t.type === 'template');
+} catch {
+  // Bundled JSON not available
+}
+
+function templateId(t: ProjectTemplate): string {
+  return basename(t.path);
+}
+
+function templateLabel(t: ProjectTemplate): string {
+  return t.variant ? `${t.name} (${t.variant})` : t.name;
+}
+
+const availableIds = templates.map(templateId);
+const availableList = templates.map((t) => `- \`${templateId(t)}\` — ${templateLabel(t)}`).join('\n');
+
+type CreateAppPayload = {
+  template: string;
+  appName: string;
+};
+
+export const createAppTool = {
+  name: 'create_app',
+  title: 'Create App',
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description:
+    'Get scaffolding instructions for a new UI5 Web Components for React application from an official template.\n\n' +
+    'WHEN TO USE: The user wants to create a new app, project, or starter using UI5 Web Components for React.\n' +
+    'WORKFLOW: Call this tool to get the template setup instructions, then execute them.\n\n' +
+    `Available templates:\n${availableList}\n\n` +
+    'EXAMPLE INPUT: { "template": "vite-ts", "appName": "my-app" }\n' +
+    'EXAMPLE INPUT: { "template": "nextjs-app", "appName": "my-dashboard" }',
+  inputSchema: {
+    template: z
+      .enum(availableIds as [string, ...string[]])
+      .describe(`Template to use. Available: ${availableIds.join(', ')}`),
+    appName: z.string().describe('Name for the new application directory'),
+  },
+  handler: ({ template, appName }: CreateAppPayload) => {
+    try {
+      const entry = templates.find((t) => templateId(t) === template);
+
+      if (!entry) {
+        return createTextResponse(`Unknown template "${template}".\n\nAvailable templates:\n${availableList}`);
+      }
+
+      const label = templateLabel(entry);
+      const degitCmd = `npx degit ${REPO}/${entry.path}#main ${appName}`;
+
+      const text = [
+        `# Scaffold: ${label} — \`${appName}\``,
+        '',
+        '## Steps',
+        '',
+        `1. Run: \`${degitCmd}\``,
+        `2. \`cd ${appName}\``,
+        `3. Update the \`name\` field in \`package.json\` to \`"${appName}"\``,
+        '4. Run: `npm install`',
+        '5. Start the dev server: `npm run dev`',
+        '',
+        '## Template Details',
+        '',
+        `- **Framework**: ${entry.name}${entry.variant ? ` (${entry.variant})` : ''}`,
+        `- **Language**: ${entry.typescript ? 'TypeScript' : 'JavaScript'}`,
+        `- **GitHub**: https://github.com/${REPO}/tree/main/${entry.path}`,
+        entry.stackBlitz ? `- **StackBlitz**: ${entry.stackBlitz}` : '',
+        '',
+        '## Post-Setup',
+        '',
+        '- ThemeProvider from `@ui5/webcomponents-react` is already configured in the template',
+        "- Import components: `import { Button, Input, Card } from '@ui5/webcomponents-react'`",
+        '- Use `get_component_api` to look up component props, events, and methods',
+        '- Use `get_documentation` for guides on styling, i18n, SSR, and more',
+      ]
+        .filter(Boolean)
+        .join('\n');
+
+      return createTextResponse(text);
+    } catch (error) {
+      return handleToolError(error, 'Error creating app scaffold');
+    }
+  },
+};
diff --git a/packages/mcp-server/src/tools/index.ts b/packages/mcp-server/src/tools/index.ts
index c02284a64d7..b6e8bc55fd8 100644
--- a/packages/mcp-server/src/tools/index.ts
+++ b/packages/mcp-server/src/tools/index.ts
@@ -1,3 +1,4 @@
+export { createAppTool } from './create_app/create_app.js';
 export { getDocumentationTool } from './get_documentation/get_documentation.js';
 export { listComponentsTool } from './list_components/list_components.js';
 export { getComponentApiTool } from './get_component_api/get_component_api.js';

From c014a72fcffddfd88ddc3b863affb58df07cf7ec Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Mon, 30 Mar 2026 12:25:36 +0200
Subject: [PATCH 10/16] cleanup & adjust README and scripts

---
 packages/mcp-server/README.md          | 200 ++++++++++++++-----------
 packages/mcp-server/package.json       |   6 +-
 packages/mcp-server/resources/llms.txt |  12 +-
 3 files changed, 120 insertions(+), 98 deletions(-)

diff --git a/packages/mcp-server/README.md b/packages/mcp-server/README.md
index f217724b660..4c34a8220b6 100644
--- a/packages/mcp-server/README.md
+++ b/packages/mcp-server/README.md
@@ -8,88 +8,57 @@ This MCP server gives AI assistants direct access to UI5 Web Components for Reac
 
 ## Features
 
-### Available Tools
+### Tools
 
-1. **`list_components`** - Browse all available components
+1. **`create_app`** - Scaffold a new application from an official template
+   - Vite (TypeScript), Next.js App Router, Next.js Pages Router
+   - Returns step-by-step setup instructions using `degit`
+
+2. **`list_components`** - Browse all available components
    - Filter by category (Data Display, Layouts & Floorplans, Inputs, Modals & Popovers, User Feedback, Charts, AI Components, Web Components)
    - Filter by package (`@ui5/webcomponents-react`, `@ui5/webcomponents-react-charts`, `@ui5/webcomponents-ai-react`)
-   - Shows component types (React vs WebComponent)
-   - Includes detailed descriptions extracted from JSDoc
-   - Provides import examples for each component
+   - Includes descriptions and import examples
 
-2. **`get_component_api`** - Full component API documentation
+3. **`get_component_api`** - Full component API documentation
    - Props with TypeScript types, descriptions, and defaults
+   - Event detail parameters (fields available on `e.detail`)
    - Ref methods and return types
+   - CSS `::part()` selectors for shadow DOM styling
+   - Sub-type documentation for complex props (e.g. AnalyticalTable column definitions)
+   - Upstream documentation links for components with complex behavioral logic
    - Case-insensitive component name matching
+   - Returns structured JSON output
 
-3. **`get_documentation`** - Comprehensive documentation sections
-   - Getting Started guide
-   - Migration guide (v1 → v2)
-   - Knowledge Base (styling, i18n, SSR, testing, slots, FAQ)
-   - Cypress Testing guides
-   - Patterns and best practices
-   - Optionally fetches full markdown content from GitHub
-
-## Setup
-
-### Prerequisites
-
-- Node.js 20.17+ or 22.9+
-
-### Configuration
-
-Add the server to your MCP client configuration. No installation needed — `npx` downloads it on demand.
-
-#### Claude Desktop / Generic MCP Client
-
-```json
-{
-  "mcpServers": {
-    "@ui5/webcomponents-react-mcp": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@ui5/webcomponents-react-mcp"]
-    }
-  }
-}
-```
-
-#### Windows (Non-WSL)
-
-```json
-{
-  "mcpServers": {
-    "@ui5/webcomponents-react-mcp": {
-      "type": "stdio",
-      "command": "cmd",
-      "args": ["/c", "npx -y @ui5/webcomponents-react-mcp"]
-    }
-  }
-}
-```
-
-#### VS Code
+4. **`get_documentation`** - Documentation, guides, and knowledge base
+   - Browse by section name or search by keyword across all docs
+   - Getting Started, Knowledge Base (styling, i18n, SSR, slots, FAQ, accessibility), project templates
+   - Full content read from bundled local files (no network required)
+   - Line-range support (`startLine`/`endLine`) for large documents
 
-```bash
-code --add-mcp '{"name":"@ui5/webcomponents-react-mcp","type":"stdio","command":"npx","args":["-y","@ui5/webcomponents-react-mcp"]}'
-```
+5. **`get_public_utils`** - Public utilities from `@ui5/webcomponents-react-base`
+   - Device API (device detection, responsive breakpoints, resize/orientation handlers)
+   - ThemingParameters (CSS variables in JavaScript)
+   - useI18nBundle hook (internationalization)
+   - useViewportRange hook (responsive breakpoint detection)
+   - withWebComponent (wrapping custom web components)
 
-#### Claude Code
+### Resources
 
-```bash
-claude mcp add --transport stdio --scope user ui5-wcr-mcp -- npx -y @ui5/webcomponents-react-mcp
-```
+- **`llms.txt`** - LLM-friendly documentation index with scope, key concepts, and quick-reference links
 
-#### Codex
+## Setup
 
-```bash
-codex mcp add --transport stdio ui5-wcr-mcp -- npx -y @ui5/webcomponents-react-mcp
-```
+> **Note:** This package is not yet published to npm. See [Local Development with Claude Code](#local-development-with-claude-code) for how to use it locally.
 
 ## Usage
 
 Once configured, your AI assistant will have access to the tools. You can ask questions like:
 
+**Create:**
+
+- "Create a new Vite app with UI5 Web Components for React"
+- "Scaffold a Next.js app with a simple dashboard"
+
 **Documentation:**
 
 - "Show me the FAQ"
@@ -110,28 +79,31 @@ Once configured, your AI assistant will have access to the tools. You can ask qu
 ### Scripts
 
 ```bash
-npm run build             # Build TypeScript + copy JSON assets
-npm run dev               # Build and run locally
-npm run inspector         # Debug with MCP Inspector (opens web UI)
-npm run type-check        # Type-check without emitting
+npm run build                 # Build TypeScript + copy JSON assets
+npm run dev                   # Build and run locally
+npm run inspector             # Debug with MCP Inspector (opens web UI)
+npm run test                  # Build and run tests in watch mode (TODO: add test files)
 npm run extract:descriptions  # Regenerate component metadata from monorepo sources
-npm run update            # Extract descriptions + rebuild
+npm run bundle:docs           # Copy documentation files from monorepo into docs/
+npm run fetch:skills          # Fetch upstream documentation (e.g. accessibility skill)
+npm run update                # Full pipeline: fetch:skills + extract:descriptions + bundle:docs + build
+npm run clean                 # Remove dist/, build cache, and all generated files
 ```
 
-### Updating Component Metadata
+### Updating After a Version Bump
 
-When `@ui5/webcomponents-react` packages are updated, regenerate the component metadata:
+When `@ui5/webcomponents-react` packages are updated, regenerate all data:
 
 ```bash
 npm run update
 ```
 
-This will:
+This runs the full pipeline:
 
-1. Extract component descriptions from JSDoc and TypeScript definitions
-2. Update component API metadata (`component-apis.json`)
-3. Update component descriptions (`descriptions.json`)
-4. Rebuild the MCP server
+1. Fetch upstream skills (accessibility docs from UI5 Web Components)
+2. Extract component descriptions and API data from monorepo TypeScript sources
+3. Bundle documentation files (copy MDX/MD from monorepo into `docs/`)
+4. Build the TypeScript server and copy JSON assets to `dist/`
 
 ### Debug Logging
 
@@ -149,19 +121,75 @@ The MCP Inspector provides a web-based UI for testing your MCP server:
 npm run inspector
 ```
 
-## How It Works
+## Architecture
+
+### Overview
+
+The MCP server is a **stdio-based** Node.js process that communicates with AI clients via the [Model Context Protocol](https://modelcontextprotocol.io/). All data is pre-processed at build time and bundled with the server — no network access is required at runtime.
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│ Build Time (npm run update)                                         │
+│                                                                     │
+│  monorepo sources ──► extract-component-descriptions.ts             │
+│    (TypeScript,        ├─► descriptions.json (component summaries)  │
+│     JSDoc, CEM)        └─► component-apis.json (full prop/method    │
+│                              data, event details, CSS parts)        │
+│                                                                     │
+│  monorepo docs ──────► bundle-docs.ts                               │
+│    (MDX, MD files)     └─► docs/ (local copies for offline access)  │
+│                                                                     │
+│  upstream skills ────► fetch-upstream-skills.ts                      │
+│    (GitHub raw)        └─► docs/upstream--accessibility.mdx          │
+└─────────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────────┐
+│ Runtime (stdio)                                                     │
+│                                                                     │
+│  AI Client ◄──► MCP Server (index.ts)                               │
+│                   ├─ create_app        reads project-templates.json  │
+│                   ├─ list_components   reads descriptions.json       │
+│                   ├─ get_component_api reads component-apis.json     │
+│                   ├─ get_documentation reads docs/ + sections.json   │
+│                   ├─ get_public_utils  hardcoded documentation       │
+│                   └─ llms.txt resource reads resources/llms.txt      │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+### Build Pipeline
+
+`npm run update` runs these steps in order:
+
+1. **`fetch:skills`** — Downloads upstream skill documents (e.g. accessibility) from GitHub, adapts HTML examples to React JSX, writes to `docs/`
+2. **`extract:descriptions`** — Uses `react-docgen-typescript` to parse component sources and Custom Elements Manifests (CEM). Outputs `descriptions.json` and `component-apis.json`. Also attaches `subTypeDocs` (markdown for complex prop types) and `docUrl` (upstream doc links) from `component-config.ts`
+3. **`bundle:docs`** — Copies MDX/MD documentation files from the monorepo into `docs/`. For JSON data sources (e.g. project templates), generates LLM-friendly markdown. Updates `localPath` fields in `documentation_sections.json`
+4. **`build`** — Compiles TypeScript, then `post-build.ts` copies JSON files from `src/` to `dist/` and makes the entry point executable
 
-This MCP server uses pre-processed metadata extracted from the `@ui5/webcomponents-react` packages. Component metadata is bundled with the server, while documentation content can optionally be fetched from GitHub at runtime.
+### Updating Component Data
 
-### Data Sources
+When components are added or removed, update `src/utils/component-config.ts`:
 
-**`list_components` & `get_component_api`**
+- **Categories** — Add new components to their category. Uncategorized components trigger a warning during `npm run extract:descriptions`.
+- **`SUB_TYPE_DOCS`** — Add markdown paths for complex prop types (e.g. AnalyticalTable column definitions)
+- **`UPSTREAM_DOC_URLS`** — Add links for components with complex behavioral logic not captured in props (e.g. Form layout)
 
-- Extracted using `react-docgen-typescript` from TypeScript definitions in the monorepo
-- Component descriptions, categories, and package info → `descriptions.json`
-- Full component APIs including props, methods, types, defaults → `component-apis.json`
+### Adding a New Tool
 
-**`get_documentation`**
+1. Create `src/tools/<tool_name>/<tool_name>.ts` following the existing pattern (name, title, annotations, description, inputSchema, handler)
+2. Export it from `src/tools/index.ts` — it will be auto-registered by `index.ts`
+
+### Local Development with Claude Code
+
+Generate all data files (only needed once, or after version bumps):
+
+```bash
+npm run update
+```
+
+Then add the server to any project using the absolute path to the built entry point:
+
+```bash
+claude mcp add --scope project ui5-wcr -- node /path/to/ui5-webcomponents-react/packages/mcp-server/dist/index.js
+```
 
-- Metadata pre-stored in `documentation_sections.json`
-- Actual content fetched at runtime via GitHub raw URLs when `fetchContent: true`
+After code changes, `npm run build` is enough.
diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index 459c447cd71..31e0973bed9 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -33,12 +33,10 @@
     "build": "tsc --build tsconfig.build.json && tsx scripts/post-build.ts",
     "fetch:skills": "tsx scripts/fetch-upstream-skills.ts",
     "update": "npm run fetch:skills && npm run extract:descriptions && npm run bundle:docs && npm run build",
-    "clean": "rimraf dist tsconfig.tsbuildinfo tsconfig.build.tsbuildinfo",
+    "clean": "rimraf dist tsconfig.tsbuildinfo tsconfig.build.tsbuildinfo src/tools/get_component_api/component-apis.json src/tools/list_components/descriptions.json docs/",
     "dev": "npm run build && node dist/index.js",
     "inspector": "npx @modelcontextprotocol/inspector node ./dist/index.js",
-    "type-check": "tsc --noEmit",
-    "test": "npm run build && ava",
-    "test:watch": "ava --watch"
+    "test": "npm run build && ava --watch"
   },
   "publishConfig": {
     "access": "public"
diff --git a/packages/mcp-server/resources/llms.txt b/packages/mcp-server/resources/llms.txt
index 5ee71ed0933..5446dc363bf 100644
--- a/packages/mcp-server/resources/llms.txt
+++ b/packages/mcp-server/resources/llms.txt
@@ -21,7 +21,8 @@ This server does NOT cover:
 
 ## Available MCP Tools
 
-- `list_components`: Browse all 203 available components by category or package. Use this first to discover component names.
+- `create_app`: Scaffold a new application from an official template (Vite, Next.js). Use when the user wants to create a new project.
+- `list_components`: Browse all available components by category or package. Use this first to discover component names.
 - `get_component_api`: Get detailed props, methods, and type information for any component. Use after list_components.
 - `get_documentation`: Read documentation guides, search across topics, and retrieve full content with line-range support.
 - `get_public_utils`: Get documentation for Device API, ThemingParameters, useI18nBundle, useViewportRange, and withWebComponent from @ui5/webcomponents-react-base.
@@ -44,11 +45,6 @@ This server does NOT cover:
 - [Styling](docs--knowledge-base--Styling.mdx): CSS variables, shadow parts (::part), custom states (:state), ThemingParameters, CSS bundles
 - [Accessibility](upstream--accessibility.mdx): Accessibility APIs, proxy attributes, label-input relationships, screen reader support
 
-### Patterns
-
-- [Architecture Patterns](docs--Patterns.mdx): Common use cases, component interactions, composition strategies
-- [SelectionAssistant (Experimental)](patterns--selection-assistant--SelectionAssistant.mdx): Advanced multi-selection with filtering and search
-
 ## Key Concepts
 
 - Web components emit CustomEvents with data in `e.detail` (not `e.value`)
@@ -56,6 +52,6 @@ This server does NOT cover:
 - Slot props require forwarding the `slot` prop to the root element
 - Shadow DOM styling uses `::part()` pseudo-element and CSS variables (`--sapBackgroundColor`, etc.)
 - Components support both React 18 and React 19+
-- Use subpath imports for @ui5/webcomponents-react-<package-refix> (e.g., `@ui5/webcomponents-react-base/hooks`)
+- Use subpath imports for @ui5/webcomponents-react-base (e.g., `@ui5/webcomponents-react-base/hooks`)
 - Web components use proxy attributes (`accessibleName`, `accessibleNameRef`) instead of standard `aria-*` for shadow DOM compatibility
-- When creating a new application, prefer official project templates (Next.js, Vite) over scaffolding from scratch. Use get_documentation({ section: "Project Templates & Examples", fetchContent: true }) to find available templates. Only fall back to generic framework setup if no template matches the user's framework.
+- When creating a new application, prefer official project templates (Next.js, Vite) over scaffolding from scratch. Use create_app to scaffold from a template. Only fall back to generic framework setup if no template matches the user's framework.

From 21af21a0b01812d60fe3c6e2731c0975684e064a Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Mon, 30 Mar 2026 12:38:51 +0200
Subject: [PATCH 11/16] update & pin deps

---
 packages/mcp-server/README.md    |  3 +-
 packages/mcp-server/package.json | 12 ++---
 yarn.lock                        | 76 ++++++++++++++++----------------
 3 files changed, 45 insertions(+), 46 deletions(-)

diff --git a/packages/mcp-server/README.md b/packages/mcp-server/README.md
index 4c34a8220b6..de67b34f7de 100644
--- a/packages/mcp-server/README.md
+++ b/packages/mcp-server/README.md
@@ -37,10 +37,9 @@ This MCP server gives AI assistants direct access to UI5 Web Components for Reac
 
 5. **`get_public_utils`** - Public utilities from `@ui5/webcomponents-react-base`
    - Device API (device detection, responsive breakpoints, resize/orientation handlers)
-   - ThemingParameters (CSS variables in JavaScript)
    - useI18nBundle hook (internationalization)
    - useViewportRange hook (responsive breakpoint detection)
-   - withWebComponent (wrapping custom web components)
+   - ThemingParameters (CSS variables in JavaScript)
 
 ### Resources
 
diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index 31e0973bed9..29f202ad18a 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -57,17 +57,17 @@
     "fiori"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@modelcontextprotocol/sdk": "1.28.0",
     "zod": "^3.25.76"
   },
   "devDependencies": {
-    "@types/node": "^22.10.0",
+    "@types/node": "22.19.15",
     "@ui5/webcomponents": "2.19.2",
     "@ui5/webcomponents-base": "2.19.2",
     "@ui5/webcomponents-react": "workspace:~",
-    "ava": "^6.4.1",
-    "glob": "^12.0.0",
-    "react-docgen-typescript": "^2.4.0",
-    "tsx": "^4.20.6"
+    "ava": "6.4.1",
+    "glob": "12.0.0",
+    "react-docgen-typescript": "2.4.0",
+    "tsx": "4.21.0"
   }
 }
diff --git a/yarn.lock b/yarn.lock
index 8b82a00ff54..58e9d74da09 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2827,9 +2827,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@modelcontextprotocol/sdk@npm:^1.27.1":
-  version: 1.27.1
-  resolution: "@modelcontextprotocol/sdk@npm:1.27.1"
+"@modelcontextprotocol/sdk@npm:1.28.0":
+  version: 1.28.0
+  resolution: "@modelcontextprotocol/sdk@npm:1.28.0"
   dependencies:
     "@hono/node-server": "npm:^1.19.9"
     ajv: "npm:^8.17.1"
@@ -2856,7 +2856,7 @@ __metadata:
       optional: true
     zod:
       optional: false
-  checksum: 10c0/1b8ad87093c9e43174c7d65864b3d826a8dd050d5c32248f5da49fd72c51b556ebd702e3e49a7f1cc7fa25717a3f7fcee22ed89edd5bd3d8f4e1f8ca499b365e
+  checksum: 10c0/eff999884bea7302b42832b7fe172a53c83ee0afd6fa42dcda29dd503d72b6f67f3d45e9eebbcecbe52e1ee418c14574b6d30ce5a0b10f947a2a680f8bb8c8c3
   languageName: node
   linkType: hard
 
@@ -4692,6 +4692,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/node@npm:22.19.15":
+  version: 22.19.15
+  resolution: "@types/node@npm:22.19.15"
+  dependencies:
+    undici-types: "npm:~6.21.0"
+  checksum: 10c0/f17eaf3d0d1da5e93ad9e287efb78201f8a5282973c004c5f70d91675c5c6b926a23acaa7b158a42b3d7e27e36b349d65a531710c91c308fca53dd7fa280ef98
+  languageName: node
+  linkType: hard
+
 "@types/node@npm:24.12.0":
   version: 24.12.0
   resolution: "@types/node@npm:24.12.0"
@@ -4710,15 +4719,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/node@npm:^22.10.0":
-  version: 22.19.15
-  resolution: "@types/node@npm:22.19.15"
-  dependencies:
-    undici-types: "npm:~6.21.0"
-  checksum: 10c0/f17eaf3d0d1da5e93ad9e287efb78201f8a5282973c004c5f70d91675c5c6b926a23acaa7b158a42b3d7e27e36b349d65a531710c91c308fca53dd7fa280ef98
-  languageName: node
-  linkType: hard
-
 "@types/normalize-package-data@npm:^2.4.0, @types/normalize-package-data@npm:^2.4.1":
   version: 2.4.4
   resolution: "@types/normalize-package-data@npm:2.4.4"
@@ -5610,15 +5610,15 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@ui5/webcomponents-react-mcp@workspace:packages/mcp-server"
   dependencies:
-    "@modelcontextprotocol/sdk": "npm:^1.27.1"
-    "@types/node": "npm:^22.10.0"
+    "@modelcontextprotocol/sdk": "npm:1.28.0"
+    "@types/node": "npm:22.19.15"
     "@ui5/webcomponents": "npm:2.19.2"
     "@ui5/webcomponents-base": "npm:2.19.2"
     "@ui5/webcomponents-react": "workspace:~"
-    ava: "npm:^6.4.1"
-    glob: "npm:^12.0.0"
-    react-docgen-typescript: "npm:^2.4.0"
-    tsx: "npm:^4.20.6"
+    ava: "npm:6.4.1"
+    glob: "npm:12.0.0"
+    react-docgen-typescript: "npm:2.4.0"
+    tsx: "npm:4.21.0"
     zod: "npm:^3.25.76"
   bin:
     ui5-wcr-mcp: ./dist/index.js
@@ -7053,7 +7053,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ava@npm:^6.4.1":
+"ava@npm:6.4.1":
   version: 6.4.1
   resolution: "ava@npm:6.4.1"
   dependencies:
@@ -12016,6 +12016,22 @@ __metadata:
   languageName: node
   linkType: hard
 
+"glob@npm:12.0.0":
+  version: 12.0.0
+  resolution: "glob@npm:12.0.0"
+  dependencies:
+    foreground-child: "npm:^3.3.1"
+    jackspeak: "npm:^4.1.1"
+    minimatch: "npm:^10.1.1"
+    minipass: "npm:^7.1.2"
+    package-json-from-dist: "npm:^1.0.0"
+    path-scurry: "npm:^2.0.0"
+  bin:
+    glob: dist/esm/bin.mjs
+  checksum: 10c0/923fbb7e30913496dc1c30191edb7ebb610a26edac81710a5f697c718b08694bce7fb0245baceba5383472778a8431ff7c36571703507cc6563602d3c139c993
+  languageName: node
+  linkType: hard
+
 "glob@npm:13.0.6, glob@npm:^13.0.0, glob@npm:^13.0.1, glob@npm:^13.0.3, glob@npm:^13.0.6":
   version: 13.0.6
   resolution: "glob@npm:13.0.6"
@@ -12059,22 +12075,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"glob@npm:^12.0.0":
-  version: 12.0.0
-  resolution: "glob@npm:12.0.0"
-  dependencies:
-    foreground-child: "npm:^3.3.1"
-    jackspeak: "npm:^4.1.1"
-    minimatch: "npm:^10.1.1"
-    minipass: "npm:^7.1.2"
-    package-json-from-dist: "npm:^1.0.0"
-    path-scurry: "npm:^2.0.0"
-  bin:
-    glob: dist/esm/bin.mjs
-  checksum: 10c0/923fbb7e30913496dc1c30191edb7ebb610a26edac81710a5f697c718b08694bce7fb0245baceba5383472778a8431ff7c36571703507cc6563602d3c139c993
-  languageName: node
-  linkType: hard
-
 "glob@npm:^7.1.3, glob@npm:^7.1.4, glob@npm:^7.1.6, glob@npm:^7.2.0, glob@npm:^7.2.3":
   version: 7.2.3
   resolution: "glob@npm:7.2.3"
@@ -18946,7 +18946,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"react-docgen-typescript@npm:^2.2.2, react-docgen-typescript@npm:^2.4.0":
+"react-docgen-typescript@npm:2.4.0, react-docgen-typescript@npm:^2.2.2":
   version: 2.4.0
   resolution: "react-docgen-typescript@npm:2.4.0"
   peerDependencies:
@@ -21387,7 +21387,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tsx@npm:^4.20.6":
+"tsx@npm:4.21.0":
   version: 4.21.0
   resolution: "tsx@npm:4.21.0"
   dependencies:

From b7a9fa0cdc4f7d458fe0ff694d3a9a0e4411924c Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Mon, 30 Mar 2026 14:59:28 +0200
Subject: [PATCH 12/16] add `ava` tests

---
 eslint.config.mjs                             |  2 +-
 packages/mcp-server/README.md                 |  2 +-
 packages/mcp-server/ava.config.js             | 11 ++++
 packages/mcp-server/package.json              |  2 +-
 .../src/tools/create_app/create_app.test.ts   | 16 ++++++
 .../get_component_api.test.ts                 | 33 +++++++++++
 .../get_documentation.test.ts                 | 56 +++++++++++++++++++
 .../get_documentation/get_documentation.ts    | 30 ++++++----
 .../list_components/list_components.test.ts   | 24 ++++++++
 packages/mcp-server/tsconfig.build.json       |  3 +-
 10 files changed, 165 insertions(+), 14 deletions(-)
 create mode 100644 packages/mcp-server/ava.config.js
 create mode 100644 packages/mcp-server/src/tools/create_app/create_app.test.ts
 create mode 100644 packages/mcp-server/src/tools/get_component_api/get_component_api.test.ts
 create mode 100644 packages/mcp-server/src/tools/get_documentation/get_documentation.test.ts
 create mode 100644 packages/mcp-server/src/tools/list_components/list_components.test.ts

diff --git a/eslint.config.mjs b/eslint.config.mjs
index 087ab9fa3a3..45c9e7bb699 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -62,7 +62,7 @@ const config = tseslint.config(
 
       parserOptions: {
         projectService: {
-          allowDefaultProject: ['packages/*/postcss.config.mjs'],
+          allowDefaultProject: ['packages/*/postcss.config.mjs', 'packages/*/ava.config.js'],
           // eslint-disable-next-line camelcase
           maximumDefaultProjectFileMatchCount_THIS_WILL_SLOW_DOWN_LINTING: 1000,
         },
diff --git a/packages/mcp-server/README.md b/packages/mcp-server/README.md
index de67b34f7de..7e51e3cc992 100644
--- a/packages/mcp-server/README.md
+++ b/packages/mcp-server/README.md
@@ -81,7 +81,7 @@ Once configured, your AI assistant will have access to the tools. You can ask qu
 npm run build                 # Build TypeScript + copy JSON assets
 npm run dev                   # Build and run locally
 npm run inspector             # Debug with MCP Inspector (opens web UI)
-npm run test                  # Build and run tests in watch mode (TODO: add test files)
+npm run test                  # Run tests in watch mode (AVA + tsx)
 npm run extract:descriptions  # Regenerate component metadata from monorepo sources
 npm run bundle:docs           # Copy documentation files from monorepo into docs/
 npm run fetch:skills          # Fetch upstream documentation (e.g. accessibility skill)
diff --git a/packages/mcp-server/ava.config.js b/packages/mcp-server/ava.config.js
new file mode 100644
index 00000000000..090c7857169
--- /dev/null
+++ b/packages/mcp-server/ava.config.js
@@ -0,0 +1,11 @@
+export default {
+  extensions: {
+    ts: 'module',
+  },
+  files: ['src/**/*.test.ts'],
+  watchMode: {
+    ignoreChanges: ['dist/**', 'node_modules/**'],
+  },
+  nodeArguments: ['--import=tsx'],
+  workerThreads: false,
+};
diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index 29f202ad18a..3a4d7bcd85a 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -36,7 +36,7 @@
     "clean": "rimraf dist tsconfig.tsbuildinfo tsconfig.build.tsbuildinfo src/tools/get_component_api/component-apis.json src/tools/list_components/descriptions.json docs/",
     "dev": "npm run build && node dist/index.js",
     "inspector": "npx @modelcontextprotocol/inspector node ./dist/index.js",
-    "test": "npm run build && ava --watch"
+    "test": "ava --watch"
   },
   "publishConfig": {
     "access": "public"
diff --git a/packages/mcp-server/src/tools/create_app/create_app.test.ts b/packages/mcp-server/src/tools/create_app/create_app.test.ts
new file mode 100644
index 00000000000..ffac4c65d24
--- /dev/null
+++ b/packages/mcp-server/src/tools/create_app/create_app.test.ts
@@ -0,0 +1,16 @@
+import test from 'ava';
+import { createAppTool } from './create_app.js';
+
+const handler = createAppTool.handler;
+
+function getText(response: ReturnType<typeof handler>): string {
+  return response.content[0].text;
+}
+
+test('handler: valid template returns degit instructions from generated project-templates.json', (t) => {
+  // docs/project-templates.json is gitignored (generated by bundle:docs)
+  // If the path or generation breaks, templates will be empty and this fails
+  const result = getText(handler({ template: 'vite-ts', appName: 'my-app' }));
+  t.true(result.includes('degit'));
+  t.true(result.includes('my-app'));
+});
diff --git a/packages/mcp-server/src/tools/get_component_api/get_component_api.test.ts b/packages/mcp-server/src/tools/get_component_api/get_component_api.test.ts
new file mode 100644
index 00000000000..e70118c6fd9
--- /dev/null
+++ b/packages/mcp-server/src/tools/get_component_api/get_component_api.test.ts
@@ -0,0 +1,33 @@
+import test from 'ava';
+import { getComponentApiTool } from './get_component_api.js';
+
+const handler = getComponentApiTool.handler;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getStructured(response: ReturnType<typeof handler>): any {
+  if (!('structuredContent' in response)) {
+    throw new Error('Expected structuredContent in response');
+  }
+  return response.structuredContent;
+}
+
+test('handler: finds component case-insensitively from generated component-apis.json', (t) => {
+  // component-apis.json is gitignored (generated by extract:descriptions)
+  // Also verifies findComponent() toLowerCase logic
+  const result = getStructured(handler({ componentName: 'button' }));
+  t.truthy(result.props);
+  t.falsy(result.error);
+});
+
+test('handler: AnalyticalTable is from @ui5/webcomponents-react', (t) => {
+  // Verifies the "components" category (separate from webComponents tested above)
+  const result = getStructured(handler({ componentName: 'AnalyticalTable' }));
+  t.is(result.package, '@ui5/webcomponents-react');
+});
+
+test('handler: not-found returns error with available components list', (t) => {
+  // Input is z.string() (not z.enum), so this path is reachable
+  const result = getStructured(handler({ componentName: 'FakeWidget' }));
+  t.is(result.errorType, 'not_found');
+  t.true(result.availableComponents.length > 0);
+});
diff --git a/packages/mcp-server/src/tools/get_documentation/get_documentation.test.ts b/packages/mcp-server/src/tools/get_documentation/get_documentation.test.ts
new file mode 100644
index 00000000000..1fd8b05e397
--- /dev/null
+++ b/packages/mcp-server/src/tools/get_documentation/get_documentation.test.ts
@@ -0,0 +1,56 @@
+import test from 'ava';
+import { sliceLines, getDocumentationTool } from './get_documentation.js';
+
+const handler = getDocumentationTool.handler;
+
+function getText(response: ReturnType<typeof handler>): string {
+  return response.content[0].text;
+}
+
+test('sliceLines: returns content unchanged when no line range specified', (t) => {
+  const content = 'line1\nline2\nline3';
+  t.is(sliceLines(content), content);
+});
+
+test('sliceLines: extracts specific line range (1-based)', (t) => {
+  const content = 'line1\nline2\nline3\nline4\nline5';
+  const result = sliceLines(content, 2, 4);
+  t.true(result.includes('[Lines 2-4 of 5]'));
+  t.true(result.includes('line2'));
+  t.true(result.includes('line4'));
+  t.false(result.includes('line1'));
+  t.false(result.includes('line5'));
+});
+
+test('handler: search query finds matching section', (t) => {
+  const result = getText(handler({ query: 'styling' }));
+  t.true(result.includes('Styling'));
+});
+
+test('handler: search with no matches returns empty message', (t) => {
+  const result = getText(handler({ query: 'xyznonexistent_garbage_query' }));
+  t.true(result.includes('No Documentation Found'));
+});
+
+test('handler: section lookup with fetchContent verifies gitignored docs exist', (t) => {
+  // docs/*.mdx files are gitignored (generated by bundle:docs)
+  // fetchContent triggers readDocContent which reads from the docs/ directory
+  const result = getText(handler({ section: 'Getting Started', fetchContent: true }));
+  t.true(result.includes('Getting Started'));
+  t.false(result.includes('bundled docs may need to be regenerated'));
+});
+
+test('handler: subsection lookup uses "Section > Subsection" format', (t) => {
+  const result = getText(handler({ section: 'Knowledge Base > Styling' }));
+  t.true(result.includes('Styling'));
+});
+
+test('handler: startLine without fetchContent returns error', (t) => {
+  const result = getText(handler({ section: 'Getting Started', startLine: 1 }));
+  t.true(result.includes('fetchContent'));
+});
+
+test('handler: section + query together returns error', (t) => {
+  const result = getText(handler({ section: 'Getting Started', query: 'styling' }));
+  t.true(result.includes('either'));
+});
diff --git a/packages/mcp-server/src/tools/get_documentation/get_documentation.ts b/packages/mcp-server/src/tools/get_documentation/get_documentation.ts
index f2b6c2989e8..28c3315eb93 100644
--- a/packages/mcp-server/src/tools/get_documentation/get_documentation.ts
+++ b/packages/mcp-server/src/tools/get_documentation/get_documentation.ts
@@ -186,6 +186,22 @@ function searchDocumentation(query: string): Array<{
 // Path to bundled documentation files
 const DOCS_DIR = join(__dirname, '..', '..', '..', 'docs');
 
+/**
+ * Extract a line range from content string.
+ * Converts 1-based user input to 0-based slicing with bounds clamping.
+ * @internal - exported for testing
+ */
+function sliceLines(content: string, startLine?: number, endLine?: number): string {
+  if (startLine || endLine) {
+    const lines = content.split('\n');
+    const start = Math.max(1, startLine || 1) - 1; // Convert to 0-indexed
+    const end = Math.min(lines.length, endLine || lines.length);
+    const sliced = lines.slice(start, end);
+    return `[Lines ${start + 1}-${end} of ${lines.length}]\n\n${sliced.join('\n')}`;
+  }
+  return content;
+}
+
 /**
  * Read documentation content from bundled local file.
  * Optionally extracts a specific line range.
@@ -205,16 +221,7 @@ function readDocContent(localPath?: string, startLine?: number, endLine?: number
     return 'Documentation content not available locally. The bundled docs may need to be regenerated with `npm run bundle:docs`.';
   }
 
-  // Apply line range if specified
-  if (startLine || endLine) {
-    const lines = fullContent.split('\n');
-    const start = Math.max(1, startLine || 1) - 1; // Convert to 0-indexed
-    const end = Math.min(lines.length, endLine || lines.length);
-    const sliced = lines.slice(start, end);
-    return `[Lines ${start + 1}-${end} of ${lines.length}]\n\n${sliced.join('\n')}`;
-  }
-
-  return fullContent;
+  return sliceLines(fullContent, startLine, endLine);
 }
 
 /**
@@ -492,3 +499,6 @@ export const getDocumentationTool = {
     }
   },
 };
+
+/** Exported for direct testing — pure line-slicing logic extracted from readDocContent */
+export { sliceLines };
diff --git a/packages/mcp-server/src/tools/list_components/list_components.test.ts b/packages/mcp-server/src/tools/list_components/list_components.test.ts
new file mode 100644
index 00000000000..ea21937a7f0
--- /dev/null
+++ b/packages/mcp-server/src/tools/list_components/list_components.test.ts
@@ -0,0 +1,24 @@
+import test from 'ava';
+import { listComponentsTool } from './list_components.js';
+
+const handler = listComponentsTool.handler;
+
+function getText(response: ReturnType<typeof handler>): string {
+  return response.content[0].text;
+}
+
+test('handler: output contains React component names from generated descriptions.json', (t) => {
+  const result = getText(handler({}));
+  // AnalyticalTable comes from DESCRIPTIONS.components (gitignored, generated by extract:descriptions)
+  // If the extraction pipeline breaks, this fails
+  t.true(result.includes('**AnalyticalTable**'));
+});
+
+test('handler: Web Components (Wrapped) category lists components with total count', (t) => {
+  const result = getText(handler({ category: 'Web Components (Wrapped)' }));
+  t.true(result.includes('Web Components (Wrapped)'));
+  // Total count comes from Object.keys(DESCRIPTIONS.webComponents) — generated data
+  const totalMatch = result.match(/\*\*Total\*\*: (\d+)/);
+  t.truthy(totalMatch, 'should include a total count');
+  t.true(Number(totalMatch![1]) > 50, 'should have a meaningful number of web components');
+});
diff --git a/packages/mcp-server/tsconfig.build.json b/packages/mcp-server/tsconfig.build.json
index fc8520e7376..0a11719fef1 100644
--- a/packages/mcp-server/tsconfig.build.json
+++ b/packages/mcp-server/tsconfig.build.json
@@ -1,3 +1,4 @@
 {
-  "extends": "./tsconfig.json"
+  "extends": "./tsconfig.json",
+  "exclude": ["src/**/*.test.ts"]
 }

From b54351e42e6f084a141334b05e12b9062fbb56df Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Mon, 30 Mar 2026 15:44:48 +0200
Subject: [PATCH 13/16] update zod to v4

---
 packages/mcp-server/package.json                      |  2 +-
 .../src/tools/get_component_api/get_component_api.ts  |  2 +-
 yarn.lock                                             | 11 ++---------
 3 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index 3a4d7bcd85a..68222072c7c 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -58,7 +58,7 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.28.0",
-    "zod": "^3.25.76"
+    "zod": "4.3.6"
   },
   "devDependencies": {
     "@types/node": "22.19.15",
diff --git a/packages/mcp-server/src/tools/get_component_api/get_component_api.ts b/packages/mcp-server/src/tools/get_component_api/get_component_api.ts
index 2f5078e54c3..b11a8d6a1de 100644
--- a/packages/mcp-server/src/tools/get_component_api/get_component_api.ts
+++ b/packages/mcp-server/src/tools/get_component_api/get_component_api.ts
@@ -128,7 +128,7 @@ EXAMPLE INPUT: { "componentName": "Dialog" }
   outputSchema: {
     package: z.string().describe('NPM package name'),
     description: z.string().describe('Full component description'),
-    props: z.record(z.any()).describe('Component props with types, descriptions, and eventDetail'),
+    props: z.record(z.string(), z.any()).describe('Component props with types, descriptions, and eventDetail'),
     methods: z.array(z.any()).describe('Imperative methods accessible via ref'),
     cssParts: z
       .array(z.object({ name: z.string(), description: z.string() }))
diff --git a/yarn.lock b/yarn.lock
index 60d1d955be9..1fa754a5b52 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5601,7 +5601,7 @@ __metadata:
     glob: "npm:12.0.0"
     react-docgen-typescript: "npm:2.4.0"
     tsx: "npm:4.21.0"
-    zod: "npm:^3.25.76"
+    zod: "npm:4.3.6"
   bin:
     ui5-wcr-mcp: ./dist/index.js
   languageName: unknown
@@ -23182,20 +23182,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"zod@npm:^3.25 || ^4.0, zod@npm:^3.25.0 || ^4.0.0":
+"zod@npm:4.3.6, zod@npm:^3.25 || ^4.0, zod@npm:^3.25.0 || ^4.0.0":
   version: 4.3.6
   resolution: "zod@npm:4.3.6"
   checksum: 10c0/860d25a81ab41d33aa25f8d0d07b091a04acb426e605f396227a796e9e800c44723ed96d0f53a512b57be3d1520f45bf69c0cb3b378a232a00787a2609625307
   languageName: node
   linkType: hard
 
-"zod@npm:^3.25.76":
-  version: 3.25.76
-  resolution: "zod@npm:3.25.76"
-  checksum: 10c0/5718ec35e3c40b600316c5b4c5e4976f7fee68151bc8f8d90ec18a469be9571f072e1bbaace10f1e85cf8892ea12d90821b200e980ab46916a6166a4260a983c
-  languageName: node
-  linkType: hard
-
 "zwitch@npm:^2.0.0, zwitch@npm:^2.0.4":
   version: 2.0.4
   resolution: "zwitch@npm:2.0.4"

From ddc2f443e65f0764e780dfd5c18829cb1a0986ab Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Mon, 30 Mar 2026 15:51:13 +0200
Subject: [PATCH 14/16] remove duplicate dev deps

---
 packages/mcp-server/package.json |   4 --
 yarn.lock                        | 114 -------------------------------
 2 files changed, 118 deletions(-)

diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index 68222072c7c..ed83cbc9d28 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -61,12 +61,8 @@
     "zod": "4.3.6"
   },
   "devDependencies": {
-    "@types/node": "22.19.15",
-    "@ui5/webcomponents": "2.19.2",
-    "@ui5/webcomponents-base": "2.19.2",
     "@ui5/webcomponents-react": "workspace:~",
     "ava": "6.4.1",
-    "glob": "12.0.0",
     "react-docgen-typescript": "2.4.0",
     "tsx": "4.21.0"
   }
diff --git a/yarn.lock b/yarn.lock
index 1fa754a5b52..e42886a8f80 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3787,13 +3787,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@sap-theming/theming-base-content@npm:11.29.3":
-  version: 11.29.3
-  resolution: "@sap-theming/theming-base-content@npm:11.29.3"
-  checksum: 10c0/8da4e8c0dafce793fb410832534eebf1f35eb1eb15f55f030810cfd32a15d45778ead2b89b04418f4e187f62f4af5afacf9a8191a7b2d5b91253715878be058e
-  languageName: node
-  linkType: hard
-
 "@sap-theming/theming-base-content@npm:11.33.0":
   version: 11.33.0
   resolution: "@sap-theming/theming-base-content@npm:11.33.0"
@@ -4674,15 +4667,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/node@npm:22.19.15":
-  version: 22.19.15
-  resolution: "@types/node@npm:22.19.15"
-  dependencies:
-    undici-types: "npm:~6.21.0"
-  checksum: 10c0/f17eaf3d0d1da5e93ad9e287efb78201f8a5282973c004c5f70d91675c5c6b926a23acaa7b158a42b3d7e27e36b349d65a531710c91c308fca53dd7fa280ef98
-  languageName: node
-  linkType: hard
-
 "@types/node@npm:24.12.0":
   version: 24.12.0
   resolution: "@types/node@npm:24.12.0"
@@ -5384,16 +5368,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ui5/webcomponents-base@npm:2.19.2":
-  version: 2.19.2
-  resolution: "@ui5/webcomponents-base@npm:2.19.2"
-  dependencies:
-    "@lit-labs/ssr-dom-shim": "npm:^1.1.2"
-    lit-html: "npm:^2.0.1"
-  checksum: 10c0/de4e73a5c557e91f3a005a3fd8983b5beac5e2e9d6016444a88d80bf6e66ea29c1828ccd64812b5f9c5f9535d34524458fd38bb6e4df09b1e08ce2c3fe66b5dd
-  languageName: node
-  linkType: hard
-
 "@ui5/webcomponents-base@npm:2.20.2":
   version: 2.20.2
   resolution: "@ui5/webcomponents-base@npm:2.20.2"
@@ -5449,15 +5423,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ui5/webcomponents-icons-business-suite@npm:2.19.2":
-  version: 2.19.2
-  resolution: "@ui5/webcomponents-icons-business-suite@npm:2.19.2"
-  dependencies:
-    "@ui5/webcomponents-base": "npm:2.19.2"
-  checksum: 10c0/65c8cd799b322fafeafa248f1fdf53c2f237a3b1615e3aff3be7bba83c302cc2389d0d5799fe7478c4f530364f5f62bb45b1e6fef5e466032f062c911889f4b7
-  languageName: node
-  linkType: hard
-
 "@ui5/webcomponents-icons-business-suite@npm:2.20.2":
   version: 2.20.2
   resolution: "@ui5/webcomponents-icons-business-suite@npm:2.20.2"
@@ -5467,15 +5432,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ui5/webcomponents-icons-tnt@npm:2.19.2":
-  version: 2.19.2
-  resolution: "@ui5/webcomponents-icons-tnt@npm:2.19.2"
-  dependencies:
-    "@ui5/webcomponents-base": "npm:2.19.2"
-  checksum: 10c0/20fe246f41ed6fdcd87cd3a1f64c8926935d9f354e65eb0baaf56ef4fc5cc32c0072b14b44a5647620b4e19d01df6dac1700ceb4a0e86e97865404b5f15edeb4
-  languageName: node
-  linkType: hard
-
 "@ui5/webcomponents-icons-tnt@npm:2.20.2":
   version: 2.20.2
   resolution: "@ui5/webcomponents-icons-tnt@npm:2.20.2"
@@ -5485,15 +5441,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ui5/webcomponents-icons@npm:2.19.2":
-  version: 2.19.2
-  resolution: "@ui5/webcomponents-icons@npm:2.19.2"
-  dependencies:
-    "@ui5/webcomponents-base": "npm:2.19.2"
-  checksum: 10c0/fc37f54d601fc30eb3867085558ec56019ff2884fa9287aa0c51901112c2d5e643d5fb47ae708cc2b85c2f223c9db10d14d4b9ed8c8f4dd6d58ad5bdbf3a1b10
-  languageName: node
-  linkType: hard
-
 "@ui5/webcomponents-icons@npm:2.20.2":
   version: 2.20.2
   resolution: "@ui5/webcomponents-icons@npm:2.20.2"
@@ -5503,16 +5450,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ui5/webcomponents-localization@npm:2.19.2":
-  version: 2.19.2
-  resolution: "@ui5/webcomponents-localization@npm:2.19.2"
-  dependencies:
-    "@types/openui5": "npm:^1.113.0"
-    "@ui5/webcomponents-base": "npm:2.19.2"
-  checksum: 10c0/65ea91adc281a544d68bf35ff103e6b813891100f75ea94acf27ca46061ecc04ae7a24cd81a236831b04162dc16342f7e65d4dcbbb8556bb99c445ac869345f6
-  languageName: node
-  linkType: hard
-
 "@ui5/webcomponents-localization@npm:2.20.2":
   version: 2.20.2
   resolution: "@ui5/webcomponents-localization@npm:2.20.2"
@@ -5593,12 +5530,8 @@ __metadata:
   resolution: "@ui5/webcomponents-react-mcp@workspace:packages/mcp-server"
   dependencies:
     "@modelcontextprotocol/sdk": "npm:1.28.0"
-    "@types/node": "npm:22.19.15"
-    "@ui5/webcomponents": "npm:2.19.2"
-    "@ui5/webcomponents-base": "npm:2.19.2"
     "@ui5/webcomponents-react": "workspace:~"
     ava: "npm:6.4.1"
-    glob: "npm:12.0.0"
     react-docgen-typescript: "npm:2.4.0"
     tsx: "npm:4.21.0"
     zod: "npm:4.3.6"
@@ -5638,16 +5571,6 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@ui5/webcomponents-theming@npm:2.19.2":
-  version: 2.19.2
-  resolution: "@ui5/webcomponents-theming@npm:2.19.2"
-  dependencies:
-    "@sap-theming/theming-base-content": "npm:11.29.3"
-    "@ui5/webcomponents-base": "npm:2.19.2"
-  checksum: 10c0/2490f054f3c2a5714086a0bf85d434c3b1ec3fe1926a59df61f1871ce7e647106c7cfb6c7be9ba4778831848ae92cd44ace2b5e9a07bcb09f00e4b384f5cc5ad
-  languageName: node
-  linkType: hard
-
 "@ui5/webcomponents-theming@npm:2.20.2":
   version: 2.20.2
   resolution: "@ui5/webcomponents-theming@npm:2.20.2"
@@ -5721,20 +5644,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ui5/webcomponents@npm:2.19.2":
-  version: 2.19.2
-  resolution: "@ui5/webcomponents@npm:2.19.2"
-  dependencies:
-    "@ui5/webcomponents-base": "npm:2.19.2"
-    "@ui5/webcomponents-icons": "npm:2.19.2"
-    "@ui5/webcomponents-icons-business-suite": "npm:2.19.2"
-    "@ui5/webcomponents-icons-tnt": "npm:2.19.2"
-    "@ui5/webcomponents-localization": "npm:2.19.2"
-    "@ui5/webcomponents-theming": "npm:2.19.2"
-  checksum: 10c0/0ca5fae571ad6a83bd2880eae4a065f7b2637e66080224c0091bba605d1b86cedb415890598c2259a85929609dd28fe623eacea1c8ca35075435a7b1ec1a2e0c
-  languageName: node
-  linkType: hard
-
 "@ui5/webcomponents@npm:2.20.2":
   version: 2.20.2
   resolution: "@ui5/webcomponents@npm:2.20.2"
@@ -12005,22 +11914,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"glob@npm:12.0.0":
-  version: 12.0.0
-  resolution: "glob@npm:12.0.0"
-  dependencies:
-    foreground-child: "npm:^3.3.1"
-    jackspeak: "npm:^4.1.1"
-    minimatch: "npm:^10.1.1"
-    minipass: "npm:^7.1.2"
-    package-json-from-dist: "npm:^1.0.0"
-    path-scurry: "npm:^2.0.0"
-  bin:
-    glob: dist/esm/bin.mjs
-  checksum: 10c0/923fbb7e30913496dc1c30191edb7ebb610a26edac81710a5f697c718b08694bce7fb0245baceba5383472778a8431ff7c36571703507cc6563602d3c139c993
-  languageName: node
-  linkType: hard
-
 "glob@npm:13.0.6, glob@npm:^13.0.0, glob@npm:^13.0.1, glob@npm:^13.0.3, glob@npm:^13.0.6":
   version: 13.0.6
   resolution: "glob@npm:13.0.6"
@@ -21750,13 +21643,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"undici-types@npm:~6.21.0":
-  version: 6.21.0
-  resolution: "undici-types@npm:6.21.0"
-  checksum: 10c0/c01ed51829b10aa72fc3ce64b747f8e74ae9b60eafa19a7b46ef624403508a54c526ffab06a14a26b3120d055e1104d7abe7c9017e83ced038ea5cf52f8d5e04
-  languageName: node
-  linkType: hard
-
 "undici-types@npm:~7.16.0":
   version: 7.16.0
   resolution: "undici-types@npm:7.16.0"

From f9afb498b4a40cf499148789650eab8f9c715eed Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Mon, 30 Mar 2026 16:03:40 +0200
Subject: [PATCH 15/16] Update package.json

---
 packages/mcp-server/package.json | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index ed83cbc9d28..cbddf0f3b0d 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -18,10 +18,6 @@
   "bin": {
     "ui5-wcr-mcp": "./dist/index.js"
   },
-  "engines": {
-    "node": "^20.17.0 || >=22.9.0",
-    "npm": ">= 8"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/UI5/webcomponents-react",
@@ -48,14 +44,6 @@
     "CHANGELOG.md",
     "README.md"
   ],
-  "keywords": [
-    "ui5",
-    "webcomponents",
-    "react",
-    "mcp",
-    "sap",
-    "fiori"
-  ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.28.0",
     "zod": "4.3.6"

From c563bf68792d63f8968db2fd37880b1a86e767fc Mon Sep 17 00:00:00 2001
From: Lukas Harbarth <lukas.harbarth@sap.com>
Date: Thu, 2 Apr 2026 08:57:46 +0200
Subject: [PATCH 16/16] Update package.json

---
 packages/mcp-server/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index cbddf0f3b0d..b4ebbc74b90 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -3,7 +3,7 @@
   "description": "Model Context Protocol server for UI5 Web Components for React - Developer documentation and API assistance",
   "author": "SAP SE (https://www.sap.com)",
   "license": "Apache-2.0",
-  "version": "2.20.0",
+  "version": "2.20.1",
   "type": "module",
   "mcpName": "io.github.UI5/webcomponents-react-mcp-server",
   "types": "./dist/index.d.ts",