From e793e79b885b9237fc6ae264d40f91c55deaa891 Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Mon, 8 Sep 2025 12:07:12 +0200
Subject: [PATCH 01/32] chore: Add new inline-code variant in Box

---
 pages/box/inline-code-example.page.tsx        | 73 +++++++++++++++++++
 .../__snapshots__/documenter.test.ts.snap     |  1 +
 src/box/interfaces.ts                         |  3 +-
 src/box/internal.tsx                          |  4 +
 src/box/text.scss                             | 11 +++
 style-dictionary/utils/token-names.ts         |  1 +
 style-dictionary/visual-refresh/colors.ts     |  1 +
 7 files changed, 93 insertions(+), 1 deletion(-)
 create mode 100644 pages/box/inline-code-example.page.tsx

diff --git a/pages/box/inline-code-example.page.tsx b/pages/box/inline-code-example.page.tsx
new file mode 100644
index 0000000000..b94510e677
--- /dev/null
+++ b/pages/box/inline-code-example.page.tsx
@@ -0,0 +1,73 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import React from 'react';
+
+import Alert from '~components/alert';
+import Box from '~components/box';
+import Flashbar from '~components/flashbar';
+import SpaceBetween from '~components/space-between';
+
+export default function InlineCodeExample() {
+  return (
+    <Box padding={{ left: 'xl', right: 'xl', top: 'xxl', bottom: 'xl' }}>
+      <SpaceBetween size="l">
+        <div>
+          <h2>Example usage</h2>
+          <p>
+            When writing documentation, you can use inline code elements to highlight variables like{' '}
+            <Box variant="awsui-inline-code">const myVariable = 42;</Box> or function names like{' '}
+            <Box variant="awsui-inline-code">calculateTotal()</Box>.
+          </p>
+        </div>
+
+        <div>
+          <h2>Alert component with inline code</h2>
+          <Alert type="info" header="Configuration Required">
+            To configure your application, set the <Box variant="awsui-inline-code">API_ENDPOINT</Box> environment
+            variable to your API URL. For example:{' '}
+            <Box variant="awsui-inline-code">export API_ENDPOINT=&quot;https://api.example.com&quot;</Box>
+          </Alert>
+
+          <Alert type="warning" header="Deprecated Function">
+            The function <Box variant="awsui-inline-code">getUserData()</Box> is deprecated. Please use{' '}
+            <Box variant="awsui-inline-code">fetchUserProfile()</Box> instead.
+          </Alert>
+        </div>
+
+        <div>
+          <h2>Flashbar component with inline code</h2>
+          <Flashbar
+            items={[
+              {
+                type: 'success',
+                header: 'Deployment successful',
+                content: (
+                  <>
+                    Your application has been deployed successfully. The new version{' '}
+                    <Box variant="awsui-inline-code">v2.1.0</Box> is now live at{' '}
+                    <Box variant="awsui-inline-code">arn:service23G2::123:distribution/23E1</Box>.
+                  </>
+                ),
+                dismissible: true,
+                id: 'success-message',
+              },
+              {
+                type: 'error',
+                header: 'Build failed',
+                content: (
+                  <>
+                    The build process failed with exit code <Box variant="awsui-inline-code">1</Box>. Check the{' '}
+                    <Box variant="awsui-inline-code">package.json</Box> file for missing dependencies or run{' '}
+                    <Box variant="awsui-inline-code">npm install</Box> to resolve issues.
+                  </>
+                ),
+                dismissible: true,
+                id: 'error-message',
+              },
+            ]}
+          />
+        </div>
+      </SpaceBetween>
+    </Box>
+  );
+}
diff --git a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
index fbc36e36b9..ffe824f8a5 100644
--- a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
+++ b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
@@ -4482,6 +4482,7 @@ Override the HTML tag by using property \`tagOverride\`.",
           "awsui-value-large",
           "awsui-key-label",
           "awsui-gen-ai-label",
+          "awsui-inline-code",
         ],
       },
       "name": "variant",
diff --git a/src/box/interfaces.ts b/src/box/interfaces.ts
index 7d8d7a16f8..d288186a27 100644
--- a/src/box/interfaces.ts
+++ b/src/box/interfaces.ts
@@ -151,7 +151,8 @@ export namespace BoxProps {
     | 'samp'
     | 'awsui-key-label'
     | 'awsui-gen-ai-label'
-    | 'awsui-value-large';
+    | 'awsui-value-large'
+    | 'awsui-inline-code';
 
   export type Display = 'block' | 'inline' | 'inline-block' | 'none';
   export type TextAlign = 'left' | 'center' | 'right';
diff --git a/src/box/internal.tsx b/src/box/internal.tsx
index a084e9f15e..f9d371877a 100644
--- a/src/box/internal.tsx
+++ b/src/box/internal.tsx
@@ -82,5 +82,9 @@ const getTag = (variant: BoxProps.Variant, tagOverride: BoxProps['tagOverride'])
     return 'div';
   }
 
+  if (variant === 'awsui-inline-code') {
+    return 'code';
+  }
+
   return variant;
 };
diff --git a/src/box/text.scss b/src/box/text.scss
index 5df964f5f9..448068784c 100644
--- a/src/box/text.scss
+++ b/src/box/text.scss
@@ -53,6 +53,17 @@
       font-weight: awsui.$font-box-value-large-weight;
       color: inherit;
     }
+    &.inline-code-variant {
+      @include base-styles.code-extra-defaults;
+      @include styles.font-body-s;
+      border-start-start-radius: awsui.$space-static-xxs;
+      border-start-end-radius: awsui.$space-static-xxs;
+      border-end-start-radius: awsui.$space-static-xxs;
+      border-end-end-radius: awsui.$space-static-xxs;
+      background: awsui.$color-background-inline-code;
+      padding-block: awsui.$space-static-xxxs;
+      padding-inline: awsui.$space-static-xxs;
+    }
     &.h1-variant.font-weight-default,
     &.h2-variant.font-weight-default,
     &.h3-variant.font-weight-default,
diff --git a/style-dictionary/utils/token-names.ts b/style-dictionary/utils/token-names.ts
index d6b7660b46..5b05fccde5 100644
--- a/style-dictionary/utils/token-names.ts
+++ b/style-dictionary/utils/token-names.ts
@@ -456,6 +456,7 @@ export type ColorsTokenName =
   | 'colorBackgroundDropdownItemHover'
   | 'colorBackgroundDropdownItemSelected'
   | 'colorBackgroundHomeHeader'
+  | 'colorBackgroundInlineCode'
   | 'colorBackgroundInputDefault'
   | 'colorBackgroundInputDisabled'
   | 'colorBackgroundItemSelected'
diff --git a/style-dictionary/visual-refresh/colors.ts b/style-dictionary/visual-refresh/colors.ts
index 8a44604d2d..9a54d56300 100644
--- a/style-dictionary/visual-refresh/colors.ts
+++ b/style-dictionary/visual-refresh/colors.ts
@@ -51,6 +51,7 @@ const tokens: StyleDictionary.ColorsDictionary = {
   colorBackgroundDropdownItemHover: { light: '{colorGrey200}', dark: '{colorGrey900}' },
   colorBackgroundDropdownItemSelected: '{colorBackgroundItemSelected}',
   colorBackgroundHomeHeader: '{colorGrey950}',
+  colorBackgroundInlineCode: { light: 'rgba(27, 35, 45, 0.1)', dark: 'rgba(255, 255, 255, 0.15)' },
   colorBackgroundInputDefault: { light: '{colorWhite}', dark: '{colorGrey850}' },
   colorBackgroundInputDisabled: { light: '{colorGrey250}', dark: '{colorGrey800}' },
   colorBackgroundItemSelected: { light: '{colorBlue50}', dark: '{colorBlue1000}' },

From 67c2b99e536b3c1f45d5691401d32d39abc0c45e Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Mon, 8 Sep 2025 12:18:22 +0200
Subject: [PATCH 02/32] chore: Increase size limit

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index f491041e74..cb5834742f 100644
--- a/package.json
+++ b/package.json
@@ -167,7 +167,7 @@
     {
       "path": "lib/components/internal/widget-exports.js",
       "brotli": false,
-      "limit": "869 kB",
+      "limit": "870 kB",
       "ignore": "react-dom"
     }
   ],

From 91f243e6b3acb49c1ff3705f6dcbd52cf1edf6ad Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Mon, 8 Sep 2025 17:07:05 +0200
Subject: [PATCH 03/32] chore: Updated example page

---
 pages/box/inline-code-example.page.tsx | 141 +++++++++++++++++++++----
 1 file changed, 121 insertions(+), 20 deletions(-)

diff --git a/pages/box/inline-code-example.page.tsx b/pages/box/inline-code-example.page.tsx
index b94510e677..56948ae2af 100644
--- a/pages/box/inline-code-example.page.tsx
+++ b/pages/box/inline-code-example.page.tsx
@@ -2,40 +2,119 @@
 // SPDX-License-Identifier: Apache-2.0
 import React from 'react';
 
-import Alert from '~components/alert';
-import Box from '~components/box';
-import Flashbar from '~components/flashbar';
-import SpaceBetween from '~components/space-between';
+import { Alert, Box, Flashbar, Header, Link, SpaceBetween, Table } from '~components';
 
 export default function InlineCodeExample() {
   return (
     <Box padding={{ left: 'xl', right: 'xl', top: 'xxl', bottom: 'xl' }}>
       <SpaceBetween size="l">
         <div>
-          <h2>Example usage</h2>
+          <h2>Example usage in paragraph</h2>
           <p>
             When writing documentation, you can use inline code elements to highlight variables like{' '}
             <Box variant="awsui-inline-code">const myVariable = 42;</Box> or function names like{' '}
-            <Box variant="awsui-inline-code">calculateTotal()</Box>.
+            <Box variant="awsui-inline-code">calculateTotal()</Box>. For example:{' '}
+            <Box variant="awsui-inline-code">export API_ENDPOINT=&quot;https://api.example.com&quot;</Box>
           </p>
         </div>
 
         <div>
-          <h2>Alert component with inline code</h2>
-          <Alert type="info" header="Configuration Required">
-            To configure your application, set the <Box variant="awsui-inline-code">API_ENDPOINT</Box> environment
-            variable to your API URL. For example:{' '}
-            <Box variant="awsui-inline-code">export API_ENDPOINT=&quot;https://api.example.com&quot;</Box>
-          </Alert>
+          <Table
+            renderAriaLive={({ firstIndex, lastIndex, totalItemsCount }) =>
+              `Displaying items ${firstIndex} to ${lastIndex} of ${totalItemsCount}`
+            }
+            columnDefinitions={[
+              {
+                id: 'variable',
+                header: 'Variable name',
+                cell: item => <Link href="#">{item.name || '-'}</Link>,
+                sortingField: 'name',
+                isRowHeader: true,
+              },
+              {
+                id: 'alt',
+                header: 'Text value',
+                cell: item => item.alt || '-',
+                sortingField: 'alt',
+              },
+              {
+                id: 'description',
+                header: 'Description',
+                cell: item => item.description || '-',
+              },
+            ]}
+            enableKeyboardNavigation={true}
+            items={[
+              {
+                name: 'Item 1',
+                alt: 'First',
+                description: (
+                  <>
+                    This is the first <Box variant="awsui-inline-code">db.t2.large</Box> item
+                  </>
+                ),
+                type: '1A',
+                size: 'Small',
+              },
+              {
+                name: 'Item 2',
+                alt: 'Second',
+                description: (
+                  <>
+                    This is the second <Box variant="awsui-inline-code">S3-aws-phoenix.example.com</Box> item
+                  </>
+                ),
+                type: '1B',
+                size: 'Large',
+              },
+              {
+                name: 'Item 3',
+                alt: 'Third',
+                description: '-',
+                type: '1A',
+                size: 'Large',
+              },
+              {
+                name: 'Item 4',
+                alt: 'Fourth',
+                description: 'This is the fourth item',
+                type: '2A',
+                size: 'Small',
+              },
+            ]}
+            loadingText="Loading resources"
+            sortingDisabled={true}
+            header={<Header> In table </Header>}
+          />
+        </div>
+
+        <div>
+          <h2>In Alert component</h2>
+          <SpaceBetween size="xs">
+            <Alert type="info" header="Configuration required">
+              To configure your application, set the <Box variant="awsui-inline-code">API_ENDPOINT</Box> environment
+              variable to your API URL.
+            </Alert>
+
+            <Alert type="warning" header="Deprecated function">
+              The function <Box variant="awsui-inline-code">getUserData()</Box> is deprecated. Please use{' '}
+              <Box variant="awsui-inline-code">fetchUserProfile()</Box> instead.
+            </Alert>
 
-          <Alert type="warning" header="Deprecated Function">
-            The function <Box variant="awsui-inline-code">getUserData()</Box> is deprecated. Please use{' '}
-            <Box variant="awsui-inline-code">fetchUserProfile()</Box> instead.
-          </Alert>
+            <Alert type="error" header="Deprecated version">
+              The function <Box variant="awsui-inline-code">getUserData()</Box> is deprecated. Please use{' '}
+              <Box variant="awsui-inline-code">fetchUserProfile()</Box> instead.
+            </Alert>
+
+            <Alert type="success" header="Versionset is set">
+              The function <Box variant="awsui-inline-code">getUserData()</Box> is deprecated. Please use{' '}
+              <Box variant="awsui-inline-code">fetchUserProfile()</Box> instead.
+            </Alert>
+          </SpaceBetween>
         </div>
 
         <div>
-          <h2>Flashbar component with inline code</h2>
+          <h2>In Flashbar component</h2>
           <Flashbar
             items={[
               {
@@ -48,7 +127,6 @@ export default function InlineCodeExample() {
                     <Box variant="awsui-inline-code">arn:service23G2::123:distribution/23E1</Box>.
                   </>
                 ),
-                dismissible: true,
                 id: 'success-message',
               },
               {
@@ -56,14 +134,37 @@ export default function InlineCodeExample() {
                 header: 'Build failed',
                 content: (
                   <>
-                    The build process failed with exit code <Box variant="awsui-inline-code">1</Box>. Check the{' '}
+                    The build process failed with exit code 1. Check the{' '}
                     <Box variant="awsui-inline-code">package.json</Box> file for missing dependencies or run{' '}
                     <Box variant="awsui-inline-code">npm install</Box> to resolve issues.
                   </>
                 ),
-                dismissible: true,
                 id: 'error-message',
               },
+              {
+                type: 'info',
+                header: 'Build information',
+                content: (
+                  <>
+                    The build process failed with exit code 1. Check the{' '}
+                    <Box variant="awsui-inline-code">package.json</Box> file for missing dependencies or run{' '}
+                    <Box variant="awsui-inline-code">npm install</Box> to resolve issues.
+                  </>
+                ),
+                id: 'info-message',
+              },
+              {
+                type: 'warning',
+                header: 'Build failed',
+                content: (
+                  <>
+                    The build process failed with exit code 1. Check the{' '}
+                    <Box variant="awsui-inline-code">package.json</Box> file for missing dependencies or run{' '}
+                    <Box variant="awsui-inline-code">npm install</Box> to resolve issues.
+                  </>
+                ),
+                id: 'warning-message',
+              },
             ]}
           />
         </div>

From e52b266147a78a50f0aba02ce93810622256cd8a Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Mon, 8 Sep 2025 17:49:36 +0200
Subject: [PATCH 04/32] chore: Update dark mode background color and example
 page

---
 pages/box/inline-code-example.page.tsx    | 319 +++++++++++-----------
 style-dictionary/visual-refresh/colors.ts |   2 +-
 2 files changed, 162 insertions(+), 159 deletions(-)

diff --git a/pages/box/inline-code-example.page.tsx b/pages/box/inline-code-example.page.tsx
index 56948ae2af..bbc986a5e1 100644
--- a/pages/box/inline-code-example.page.tsx
+++ b/pages/box/inline-code-example.page.tsx
@@ -6,169 +6,172 @@ import { Alert, Box, Flashbar, Header, Link, SpaceBetween, Table } from '~compon
 
 export default function InlineCodeExample() {
   return (
-    <Box padding={{ left: 'xl', right: 'xl', top: 'xxl', bottom: 'xl' }}>
-      <SpaceBetween size="l">
-        <div>
-          <h2>Example usage in paragraph</h2>
-          <p>
-            When writing documentation, you can use inline code elements to highlight variables like{' '}
-            <Box variant="awsui-inline-code">const myVariable = 42;</Box> or function names like{' '}
-            <Box variant="awsui-inline-code">calculateTotal()</Box>. For example:{' '}
-            <Box variant="awsui-inline-code">export API_ENDPOINT=&quot;https://api.example.com&quot;</Box>
-          </p>
-        </div>
+    <>
+      <h1>Inline-code examples</h1>
+      <Box padding={{ left: 'xl', right: 'xl', top: 'xxl', bottom: 'xl' }}>
+        <SpaceBetween size="l">
+          <div>
+            <h2>Example usage in paragraph</h2>
+            <p>
+              When writing documentation, you can use inline code elements to highlight variables like{' '}
+              <Box variant="awsui-inline-code">const myVariable = 42;</Box> or function names like{' '}
+              <Box variant="awsui-inline-code">calculateTotal()</Box>. For example:{' '}
+              <Box variant="awsui-inline-code">export API_ENDPOINT=&quot;https://api.example.com&quot;</Box>
+            </p>
+          </div>
 
-        <div>
-          <Table
-            renderAriaLive={({ firstIndex, lastIndex, totalItemsCount }) =>
-              `Displaying items ${firstIndex} to ${lastIndex} of ${totalItemsCount}`
-            }
-            columnDefinitions={[
-              {
-                id: 'variable',
-                header: 'Variable name',
-                cell: item => <Link href="#">{item.name || '-'}</Link>,
-                sortingField: 'name',
-                isRowHeader: true,
-              },
-              {
-                id: 'alt',
-                header: 'Text value',
-                cell: item => item.alt || '-',
-                sortingField: 'alt',
-              },
-              {
-                id: 'description',
-                header: 'Description',
-                cell: item => item.description || '-',
-              },
-            ]}
-            enableKeyboardNavigation={true}
-            items={[
-              {
-                name: 'Item 1',
-                alt: 'First',
-                description: (
-                  <>
-                    This is the first <Box variant="awsui-inline-code">db.t2.large</Box> item
-                  </>
-                ),
-                type: '1A',
-                size: 'Small',
-              },
-              {
-                name: 'Item 2',
-                alt: 'Second',
-                description: (
-                  <>
-                    This is the second <Box variant="awsui-inline-code">S3-aws-phoenix.example.com</Box> item
-                  </>
-                ),
-                type: '1B',
-                size: 'Large',
-              },
-              {
-                name: 'Item 3',
-                alt: 'Third',
-                description: '-',
-                type: '1A',
-                size: 'Large',
-              },
-              {
-                name: 'Item 4',
-                alt: 'Fourth',
-                description: 'This is the fourth item',
-                type: '2A',
-                size: 'Small',
-              },
-            ]}
-            loadingText="Loading resources"
-            sortingDisabled={true}
-            header={<Header> In table </Header>}
-          />
-        </div>
+          <div>
+            <Table
+              renderAriaLive={({ firstIndex, lastIndex, totalItemsCount }) =>
+                `Displaying items ${firstIndex} to ${lastIndex} of ${totalItemsCount}`
+              }
+              columnDefinitions={[
+                {
+                  id: 'variable',
+                  header: 'Variable name',
+                  cell: item => <Link href="#">{item.name || '-'}</Link>,
+                  sortingField: 'name',
+                  isRowHeader: true,
+                },
+                {
+                  id: 'alt',
+                  header: 'Text value',
+                  cell: item => item.alt || '-',
+                  sortingField: 'alt',
+                },
+                {
+                  id: 'description',
+                  header: 'Description',
+                  cell: item => item.description || '-',
+                },
+              ]}
+              enableKeyboardNavigation={true}
+              items={[
+                {
+                  name: 'Item 1',
+                  alt: 'First',
+                  description: (
+                    <>
+                      This is the first <Box variant="awsui-inline-code">db.t2.large</Box> item
+                    </>
+                  ),
+                  type: '1A',
+                  size: 'Small',
+                },
+                {
+                  name: 'Item 2',
+                  alt: 'Second',
+                  description: (
+                    <>
+                      This is the second <Box variant="awsui-inline-code">S3-aws-phoenix.example.com</Box> item
+                    </>
+                  ),
+                  type: '1B',
+                  size: 'Large',
+                },
+                {
+                  name: 'Item 3',
+                  alt: 'Third',
+                  description: '-',
+                  type: '1A',
+                  size: 'Large',
+                },
+                {
+                  name: 'Item 4',
+                  alt: 'Fourth',
+                  description: 'This is the fourth item',
+                  type: '2A',
+                  size: 'Small',
+                },
+              ]}
+              loadingText="Loading resources"
+              sortingDisabled={true}
+              header={<Header> In table </Header>}
+            />
+          </div>
 
-        <div>
-          <h2>In Alert component</h2>
-          <SpaceBetween size="xs">
-            <Alert type="info" header="Configuration required">
-              To configure your application, set the <Box variant="awsui-inline-code">API_ENDPOINT</Box> environment
-              variable to your API URL.
-            </Alert>
+          <div>
+            <h2>In Alert component</h2>
+            <SpaceBetween size="xs">
+              <Alert type="info" header="Configuration required">
+                To configure your application, set the <Box variant="awsui-inline-code">API_ENDPOINT</Box> environment
+                variable to your API URL.
+              </Alert>
 
-            <Alert type="warning" header="Deprecated function">
-              The function <Box variant="awsui-inline-code">getUserData()</Box> is deprecated. Please use{' '}
-              <Box variant="awsui-inline-code">fetchUserProfile()</Box> instead.
-            </Alert>
+              <Alert type="warning" header="Deprecated function">
+                The function <Box variant="awsui-inline-code">getUserData()</Box> is deprecated. Please use{' '}
+                <Box variant="awsui-inline-code">fetchUserProfile()</Box> instead.
+              </Alert>
 
-            <Alert type="error" header="Deprecated version">
-              The function <Box variant="awsui-inline-code">getUserData()</Box> is deprecated. Please use{' '}
-              <Box variant="awsui-inline-code">fetchUserProfile()</Box> instead.
-            </Alert>
+              <Alert type="error" header="Deprecated version">
+                The function <Box variant="awsui-inline-code">getUserData()</Box> is deprecated. Please use{' '}
+                <Box variant="awsui-inline-code">fetchUserProfile()</Box> instead.
+              </Alert>
 
-            <Alert type="success" header="Versionset is set">
-              The function <Box variant="awsui-inline-code">getUserData()</Box> is deprecated. Please use{' '}
-              <Box variant="awsui-inline-code">fetchUserProfile()</Box> instead.
-            </Alert>
-          </SpaceBetween>
-        </div>
+              <Alert type="success" header="Versionset is set">
+                The function <Box variant="awsui-inline-code">getUserData()</Box> is deprecated. Please use{' '}
+                <Box variant="awsui-inline-code">fetchUserProfile()</Box> instead.
+              </Alert>
+            </SpaceBetween>
+          </div>
 
-        <div>
-          <h2>In Flashbar component</h2>
-          <Flashbar
-            items={[
-              {
-                type: 'success',
-                header: 'Deployment successful',
-                content: (
-                  <>
-                    Your application has been deployed successfully. The new version{' '}
-                    <Box variant="awsui-inline-code">v2.1.0</Box> is now live at{' '}
-                    <Box variant="awsui-inline-code">arn:service23G2::123:distribution/23E1</Box>.
-                  </>
-                ),
-                id: 'success-message',
-              },
-              {
-                type: 'error',
-                header: 'Build failed',
-                content: (
-                  <>
-                    The build process failed with exit code 1. Check the{' '}
-                    <Box variant="awsui-inline-code">package.json</Box> file for missing dependencies or run{' '}
-                    <Box variant="awsui-inline-code">npm install</Box> to resolve issues.
-                  </>
-                ),
-                id: 'error-message',
-              },
-              {
-                type: 'info',
-                header: 'Build information',
-                content: (
-                  <>
-                    The build process failed with exit code 1. Check the{' '}
-                    <Box variant="awsui-inline-code">package.json</Box> file for missing dependencies or run{' '}
-                    <Box variant="awsui-inline-code">npm install</Box> to resolve issues.
-                  </>
-                ),
-                id: 'info-message',
-              },
-              {
-                type: 'warning',
-                header: 'Build failed',
-                content: (
-                  <>
-                    The build process failed with exit code 1. Check the{' '}
-                    <Box variant="awsui-inline-code">package.json</Box> file for missing dependencies or run{' '}
-                    <Box variant="awsui-inline-code">npm install</Box> to resolve issues.
-                  </>
-                ),
-                id: 'warning-message',
-              },
-            ]}
-          />
-        </div>
-      </SpaceBetween>
-    </Box>
+          <div>
+            <h2>In Flashbar component</h2>
+            <Flashbar
+              items={[
+                {
+                  type: 'success',
+                  header: 'Deployment successful',
+                  content: (
+                    <>
+                      Your application has been deployed successfully. The new version{' '}
+                      <Box variant="awsui-inline-code">v2.1.0</Box> is now live at{' '}
+                      <Box variant="awsui-inline-code">arn:service23G2::123:distribution/23E1</Box>.
+                    </>
+                  ),
+                  id: 'success-message',
+                },
+                {
+                  type: 'error',
+                  header: 'Build failed',
+                  content: (
+                    <>
+                      The build process failed with exit code 1. Check the{' '}
+                      <Box variant="awsui-inline-code">package.json</Box> file for missing dependencies or run{' '}
+                      <Box variant="awsui-inline-code">npm install</Box> to resolve issues.
+                    </>
+                  ),
+                  id: 'error-message',
+                },
+                {
+                  type: 'info',
+                  header: 'Build information',
+                  content: (
+                    <>
+                      The build process failed with exit code 1. Check the{' '}
+                      <Box variant="awsui-inline-code">package.json</Box> file for missing dependencies or run{' '}
+                      <Box variant="awsui-inline-code">npm install</Box> to resolve issues.
+                    </>
+                  ),
+                  id: 'info-message',
+                },
+                {
+                  type: 'warning',
+                  header: 'Build failed',
+                  content: (
+                    <>
+                      The build process failed with exit code 1. Check the{' '}
+                      <Box variant="awsui-inline-code">package.json</Box> file for missing dependencies or run{' '}
+                      <Box variant="awsui-inline-code">npm install</Box> to resolve issues.
+                    </>
+                  ),
+                  id: 'warning-message',
+                },
+              ]}
+            />
+          </div>
+        </SpaceBetween>
+      </Box>
+    </>
   );
 }
diff --git a/style-dictionary/visual-refresh/colors.ts b/style-dictionary/visual-refresh/colors.ts
index 9a54d56300..2411f859cf 100644
--- a/style-dictionary/visual-refresh/colors.ts
+++ b/style-dictionary/visual-refresh/colors.ts
@@ -51,7 +51,7 @@ const tokens: StyleDictionary.ColorsDictionary = {
   colorBackgroundDropdownItemHover: { light: '{colorGrey200}', dark: '{colorGrey900}' },
   colorBackgroundDropdownItemSelected: '{colorBackgroundItemSelected}',
   colorBackgroundHomeHeader: '{colorGrey950}',
-  colorBackgroundInlineCode: { light: 'rgba(27, 35, 45, 0.1)', dark: 'rgba(255, 255, 255, 0.15)' },
+  colorBackgroundInlineCode: { light: 'rgba(0, 0, 0, 0.1)', dark: 'rgba(255, 255, 255, 0.1)' },
   colorBackgroundInputDefault: { light: '{colorWhite}', dark: '{colorGrey850}' },
   colorBackgroundInputDisabled: { light: '{colorGrey250}', dark: '{colorGrey800}' },
   colorBackgroundItemSelected: { light: '{colorBlue50}', dark: '{colorBlue1000}' },

From 8e5d46878c0a6250f58d701b54ee20f9e6c8299a Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Mon, 8 Sep 2025 18:26:02 +0200
Subject: [PATCH 05/32] Add specific background opacity value for flashbar
 context for a11y color contrast

---
 style-dictionary/visual-refresh/contexts/flashbar.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/style-dictionary/visual-refresh/contexts/flashbar.ts b/style-dictionary/visual-refresh/contexts/flashbar.ts
index 092077c745..0cbda207ae 100644
--- a/style-dictionary/visual-refresh/contexts/flashbar.ts
+++ b/style-dictionary/visual-refresh/contexts/flashbar.ts
@@ -24,6 +24,7 @@ export const baseTokens: StyleDictionary.ColorsDictionary = {
   colorBorderDividerDefault: '{colorGrey100}',
   colorTextTutorialHotspotDefault: '{colorGrey300}',
   colorTextTutorialHotspotHover: '{colorGrey100}',
+  colorBackgroundInlineCode: 'rgba(0, 0, 0, 0.15)',
 };
 
 const expandedTokens: StyleDictionary.ExpandedColorScopeDictionary = expandColorDictionary(

From b6f297573f59b923e93677823545350318db589e Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Mon, 8 Sep 2025 18:34:43 +0200
Subject: [PATCH 06/32] Adjsut background opacity for warning flashbar

---
 style-dictionary/visual-refresh/contexts/flashbar-warning.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/style-dictionary/visual-refresh/contexts/flashbar-warning.ts b/style-dictionary/visual-refresh/contexts/flashbar-warning.ts
index 3f11e758ae..9ef63247b0 100644
--- a/style-dictionary/visual-refresh/contexts/flashbar-warning.ts
+++ b/style-dictionary/visual-refresh/contexts/flashbar-warning.ts
@@ -39,6 +39,9 @@ export const sharedTokens: StyleDictionary.ColorsDictionary = {
   // Tutorial hotspot
   colorTextTutorialHotspotDefault: '{colorGrey600}',
   colorTextTutorialHotspotHover: '{colorGrey900}',
+
+  // Inline-code variant background in Box
+  colorBackgroundInlineCode: 'rgba(0, 0, 0, 0.1)',
 };
 
 const tokens: StyleDictionary.ColorsDictionary = {

From b0f7d1cdf59822bb0b8dd7c773198d8f57ff7048 Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Mon, 8 Sep 2025 21:36:37 +0200
Subject: [PATCH 07/32] Update example page

---
 pages/box/inline-code-example.page.tsx | 28 ++++++++++++++++++++------
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/pages/box/inline-code-example.page.tsx b/pages/box/inline-code-example.page.tsx
index bbc986a5e1..ae8a623f7a 100644
--- a/pages/box/inline-code-example.page.tsx
+++ b/pages/box/inline-code-example.page.tsx
@@ -2,7 +2,22 @@
 // SPDX-License-Identifier: Apache-2.0
 import React from 'react';
 
-import { Alert, Box, Flashbar, Header, Link, SpaceBetween, Table } from '~components';
+import Alert from '~components/alert';
+import Box from '~components/box';
+import Flashbar from '~components/flashbar';
+import Header from '~components/header';
+import Link from '~components/link';
+import SpaceBetween from '~components/space-between';
+import Table from '~components/table';
+import { TableProps } from '~components/table';
+
+interface TableItem {
+  name: string;
+  alt: string;
+  description: React.ReactNode;
+  type: string;
+  size: string;
+}
 
 export default function InlineCodeExample() {
   return (
@@ -21,28 +36,29 @@ export default function InlineCodeExample() {
           </div>
 
           <div>
-            <Table
-              renderAriaLive={({ firstIndex, lastIndex, totalItemsCount }) =>
+            <Table<TableItem>
+              totalItemsCount={4}
+              renderAriaLive={({ firstIndex, lastIndex, totalItemsCount }: TableProps.LiveAnnouncement) =>
                 `Displaying items ${firstIndex} to ${lastIndex} of ${totalItemsCount}`
               }
               columnDefinitions={[
                 {
                   id: 'variable',
                   header: 'Variable name',
-                  cell: item => <Link href="#">{item.name || '-'}</Link>,
+                  cell: (item: TableItem) => <Link href="#">{item.name || '-'}</Link>,
                   sortingField: 'name',
                   isRowHeader: true,
                 },
                 {
                   id: 'alt',
                   header: 'Text value',
-                  cell: item => item.alt || '-',
+                  cell: (item: TableItem) => item.alt || '-',
                   sortingField: 'alt',
                 },
                 {
                   id: 'description',
                   header: 'Description',
-                  cell: item => item.description || '-',
+                  cell: (item: TableItem) => item.description || '-',
                 },
               ]}
               enableKeyboardNavigation={true}

From dc6fd451f6099d05aa96d8105a593a70142b3a3a Mon Sep 17 00:00:00 2001
From: Georgii Lobko <47106899+georgylobko@users.noreply.github.com>
Date: Tue, 9 Sep 2025 16:27:24 +0200
Subject: [PATCH 08/32] feat: AI drawer header actions (#3824)

---
 package.json                                  |  2 +-
 .../external-global-left-panel-widget.tsx     | 47 ++++++----
 pages/app-layout/utils/external-widget.tsx    | 31 +++++--
 .../__integ__/runtime-drawers.test.ts         |  9 +-
 .../runtime-drawers-widgetized.test.tsx       |  2 +-
 .../__tests__/runtime-drawers.test.tsx        | 57 ++++++++----
 src/app-layout/__tests__/utils.tsx            | 29 +++++--
 src/app-layout/runtime-drawer/index.tsx       | 24 +++++
 .../drawer/global-ai-drawer.tsx               | 80 ++++++++++-------
 .../drawer/global-drawer.tsx                  | 87 ++++++++++++-------
 .../visual-refresh-toolbar/interfaces.ts      |  4 +
 src/button-group/icon-button-item.tsx         |  5 +-
 src/button-group/interfaces.ts                | 12 +++
 src/internal/plugins/controllers/drawers.ts   |  3 +
 src/internal/plugins/widget/interfaces.ts     |  3 +
 15 files changed, 281 insertions(+), 114 deletions(-)

diff --git a/package.json b/package.json
index cb5834742f..cbff2ebddf 100644
--- a/package.json
+++ b/package.json
@@ -167,7 +167,7 @@
     {
       "path": "lib/components/internal/widget-exports.js",
       "brotli": false,
-      "limit": "870 kB",
+      "limit": "890 kB",
       "ignore": "react-dom"
     }
   ],
diff --git a/pages/app-layout/utils/external-global-left-panel-widget.tsx b/pages/app-layout/utils/external-global-left-panel-widget.tsx
index 445905672d..007fd959f0 100644
--- a/pages/app-layout/utils/external-global-left-panel-widget.tsx
+++ b/pages/app-layout/utils/external-global-left-panel-widget.tsx
@@ -4,8 +4,6 @@ import React from 'react';
 import ReactDOM, { unmountComponentAtNode } from 'react-dom';
 
 import { Box } from '~components';
-import Button from '~components/button';
-import ButtonDropdown from '~components/button-dropdown';
 import { registerLeftDrawer } from '~components/internal/plugins/widget';
 
 import styles from '../styles.scss';
@@ -69,20 +67,37 @@ registerLeftDrawer({
   unmountContent: container => unmountComponentAtNode(container),
 
   mountHeader: container => {
-    ReactDOM.render(
-      <div style={{ inlineSize: '100%', display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
-        <div className={styles['ai-panel-logo']}>AI Panel</div>
-        <div>
-          <ButtonDropdown
-            items={[{ id: 'settings', text: 'Settings' }]}
-            ariaLabel="AI Panel additional options"
-            variant="icon"
-          />
-          <Button iconName="add-plus" variant="icon" ariaLabel="Add a new chat" />
-        </div>
-      </div>,
-      container
-    );
+    ReactDOM.render(<div className={styles['ai-panel-logo']}>AI Panel</div>, container);
   },
   unmountHeader: container => unmountComponentAtNode(container),
+
+  headerActions: [
+    {
+      type: 'menu-dropdown',
+      id: 'more-actions',
+      text: 'More actions',
+      items: [
+        {
+          id: 'add',
+          iconName: 'add-plus',
+          text: 'Add',
+        },
+        {
+          id: 'remove',
+          iconName: 'remove',
+          text: 'Remove',
+        },
+      ],
+    },
+    {
+      type: 'icon-button',
+      id: 'add',
+      iconName: 'add-plus',
+      text: 'Add',
+    },
+  ],
+
+  onHeaderActionClick: ({ detail }) => {
+    console.log('onHeaderActionClick: ', detail);
+  },
 });
diff --git a/pages/app-layout/utils/external-widget.tsx b/pages/app-layout/utils/external-widget.tsx
index 1fd2d3fa2b..d010b011e2 100644
--- a/pages/app-layout/utils/external-widget.tsx
+++ b/pages/app-layout/utils/external-widget.tsx
@@ -4,7 +4,6 @@ import React, { useEffect, useImperativeHandle, useRef, useState } from 'react';
 import ReactDOM, { unmountComponentAtNode } from 'react-dom';
 
 import Box from '~components/box';
-import ButtonDropdown from '~components/button-dropdown';
 import Drawer from '~components/drawer';
 import awsuiPlugins from '~components/internal/plugins';
 
@@ -67,6 +66,17 @@ awsuiPlugins.appLayout.registerDrawer({
     ReactDOM.render(<Content ref={setSizeRef} />, container);
   },
   unmountContent: container => unmountComponentAtNode(container),
+  headerActions: [
+    {
+      type: 'icon-button',
+      id: 'add',
+      iconName: 'add-plus',
+      text: 'Add',
+    },
+  ],
+  onHeaderActionClick: ({ detail }) => {
+    console.log('onHeaderActionClick: ', detail);
+  },
 });
 
 awsuiPlugins.appLayout.registerDrawer({
@@ -140,6 +150,7 @@ awsuiPlugins.appLayout.registerDrawer({
     content: 'Content',
     triggerButton: 'Trigger button',
     resizeHandle: 'Resize handle',
+    expandedModeButton: 'Expanded mode button',
   },
   onToggle: event => {
     console.log('circle-global drawer on toggle', event.detail);
@@ -158,12 +169,7 @@ awsuiPlugins.appLayout.registerDrawer({
 
   mountContent: (container, mountContext) => {
     ReactDOM.render(
-      <Drawer
-        header={<Box variant="h2">Global drawer</Box>}
-        headerActions={
-          <ButtonDropdown items={[{ id: 'settings', text: 'Settings' }]} ariaLabel="Control drawer" variant="icon" />
-        }
-      >
+      <Drawer header={<Box variant="h2">Global drawer</Box>}>
         <AutoIncrementCounter onVisibilityChange={mountContext?.onVisibilityChange}>
           global widget content circle 1
           {new Array(100).fill(null).map((_, index) => (
@@ -176,6 +182,17 @@ awsuiPlugins.appLayout.registerDrawer({
     );
   },
   unmountContent: container => unmountComponentAtNode(container),
+  headerActions: [
+    {
+      type: 'icon-button',
+      id: 'add',
+      iconName: 'add-plus',
+      text: 'Add',
+    },
+  ],
+  onHeaderActionClick: ({ detail }) => {
+    console.log('onHeaderActionClick: ', detail);
+  },
 });
 
 awsuiPlugins.appLayout.registerDrawer({
diff --git a/src/app-layout/__integ__/runtime-drawers.test.ts b/src/app-layout/__integ__/runtime-drawers.test.ts
index e8becfdabc..f2597a21dc 100644
--- a/src/app-layout/__integ__/runtime-drawers.test.ts
+++ b/src/app-layout/__integ__/runtime-drawers.test.ts
@@ -3,12 +3,11 @@
 import { BasePageObject } from '@cloudscape-design/browser-test-tools/page-objects';
 import useBrowser from '@cloudscape-design/browser-test-tools/use-browser';
 
-import createWrapper, { AppLayoutWrapper } from '../../../lib/components/test-utils/selectors';
+import createWrapper, { AppLayoutWrapper, ButtonGroupWrapper } from '../../../lib/components/test-utils/selectors';
 import { Theme } from '../../__integ__/utils.js';
 import { viewports } from './constants';
 import { getUrlParams } from './utils';
 
-import testUtilsStyles from '../../../lib/components/app-layout/test-classes/styles.selectors.js';
 import vrDrawerStyles from '../../../lib/components/app-layout/visual-refresh/styles.selectors.js';
 import vrToolbarDrawerStyles from '../../../lib/components/app-layout/visual-refresh-toolbar/drawer/styles.selectors.js';
 
@@ -21,9 +20,9 @@ const findDrawerContentById = (wrapper: AppLayoutWrapper, id: string) => {
 };
 
 const findExpandedModeButtonByActiveDrawerId = (wrapper: AppLayoutWrapper, id: string) => {
-  return wrapper.find(
-    `[data-testid="awsui-app-layout-drawer-${id}"] .${testUtilsStyles['active-drawer-expanded-mode-button']}`
-  );
+  return wrapper
+    .findComponent(`[data-testid="awsui-app-layout-drawer-${id}"]`, ButtonGroupWrapper)!
+    .findButtonById('expand');
 };
 
 describe.each(['classic', 'refresh', 'refresh-toolbar'] as Theme[])('%s', theme => {
diff --git a/src/app-layout/__tests__/runtime-drawers-widgetized.test.tsx b/src/app-layout/__tests__/runtime-drawers-widgetized.test.tsx
index 1bcd908e42..dcc32b9095 100644
--- a/src/app-layout/__tests__/runtime-drawers-widgetized.test.tsx
+++ b/src/app-layout/__tests__/runtime-drawers-widgetized.test.tsx
@@ -168,7 +168,7 @@ describeEachAppLayout({ themes: ['refresh-toolbar'] }, ({ size }) => {
     if (size === 'mobile') {
       expect(globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerDefaults.id)).toBeFalsy();
     } else {
-      globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerDefaults.id)!.click();
+      createWrapper().findButtonGroup()!.findButtonById('expand')!.click();
       expect(globalDrawersWrapper.findDrawerById(drawerDefaults.id)!.isDrawerInExpandedMode()).toBe(true);
       expect(globalDrawersWrapper.isLayoutInDrawerExpandedMode()).toBe(true);
       globalDrawersWrapper.findLeaveExpandedModeButtonInAIDrawer()!.click();
diff --git a/src/app-layout/__tests__/runtime-drawers.test.tsx b/src/app-layout/__tests__/runtime-drawers.test.tsx
index 55112c3250..45ddfdbb06 100644
--- a/src/app-layout/__tests__/runtime-drawers.test.tsx
+++ b/src/app-layout/__tests__/runtime-drawers.test.tsx
@@ -50,6 +50,7 @@ async function renderComponent(jsx: React.ReactElement) {
     globalDrawersWrapper,
     rerender,
     getByTestId,
+    container,
     ...rest,
   };
 }
@@ -946,6 +947,9 @@ describe('toolbar mode only features', () => {
           awsuiWidgetPlugins.registerLeftDrawer(payload as WidgetDrawerPayload);
         }
       };
+      const findDrawerHeaderActionById = (id: string, renderProps: Awaited<ReturnType<typeof renderComponent>>) => {
+        return createWrapper(renderProps.container).findButtonGroup()!.findButtonById(id);
+      };
 
       test('renders resize handle for a global drawer when config is enabled', async () => {
         registerDrawer({
@@ -990,7 +994,7 @@ describe('toolbar mode only features', () => {
 
         findDrawerTriggerById('global-drawer', renderProps)!.click();
         expect(globalDrawersWrapper.findDrawerById('global-drawer')!.getElement()).toBeInTheDocument();
-        globalDrawersWrapper.findCloseButtonByActiveDrawerId('global-drawer')!.click();
+        renderProps.globalDrawersWrapper.findCloseButtonByActiveDrawerId('global-drawer')!.click();
         expect(globalDrawersWrapper.findDrawerById('global-drawer')).toBeNull();
       });
 
@@ -1074,7 +1078,7 @@ describe('toolbar mode only features', () => {
         findDrawerTriggerById('global-drawer-1', renderProps)!.focus();
         findDrawerTriggerById('global-drawer-1', renderProps)!.click();
         expect(globalDrawersWrapper.findDrawerById('global-drawer-1')!.getElement()).toBeInTheDocument();
-        globalDrawersWrapper.findCloseButtonByActiveDrawerId('global-drawer-1')!.click();
+        renderProps.globalDrawersWrapper.findCloseButtonByActiveDrawerId('global-drawer-1')!.click();
         expect(globalDrawersWrapper.findDrawerById('global-drawer-1')).toBeNull();
         await waitFor(() => {
           expect(findDrawerTriggerById('global-drawer-1', renderProps)!.getElement()).toHaveFocus();
@@ -1099,7 +1103,7 @@ describe('toolbar mode only features', () => {
         await delay();
 
         expect(globalDrawersWrapper.findDrawerById('global-drawer-1')!.isActive()).toBe(true);
-        globalDrawersWrapper.findCloseButtonByActiveDrawerId('global-drawer-1')!.click();
+        renderProps.globalDrawersWrapper.findCloseButtonByActiveDrawerId('global-drawer-1')!.click();
 
         expect(globalDrawersWrapper.findDrawerById('global-drawer-1')!.getElement()).toBeInTheDocument();
         expect(globalDrawersWrapper.findDrawerById('global-drawer-1')!.isActive()).toBe(false);
@@ -1129,7 +1133,7 @@ describe('toolbar mode only features', () => {
         expect(globalDrawersWrapper.findDrawerById('global-drawer-1')!.isActive()).toBe(true);
         expect(onVisibilityChangeMock).toHaveBeenCalledWith(true);
 
-        globalDrawersWrapper.findCloseButtonByActiveDrawerId('global-drawer-1')!.click();
+        renderProps.globalDrawersWrapper.findCloseButtonByActiveDrawerId('global-drawer-1')!.click();
         expect(onVisibilityChangeMock).toHaveBeenCalledWith(false);
       });
 
@@ -1186,6 +1190,28 @@ describe('toolbar mode only features', () => {
         renderProps.globalDrawersWrapper.findCloseButtonByActiveDrawerId('global-drawer')!.click();
         expect(onToggle).toHaveBeenCalledWith({ isOpen: false, initiatedByUserAction: true });
       });
+
+      test(`calls onHeaderActionClick handler by clicking on drawers header action button in left runtime drawer)`, async () => {
+        const onHeaderActionClick = jest.fn();
+        registerDrawer({
+          ...drawerDefaults,
+          id: 'global-drawer',
+          headerActions: [
+            {
+              type: 'icon-button',
+              id: 'add',
+              iconName: 'add-plus',
+              text: 'Add',
+            },
+          ],
+          onHeaderActionClick: event => onHeaderActionClick(event.detail),
+        });
+        const renderProps = await renderComponent(<AppLayout />);
+        findDrawerTriggerById('global-drawer', renderProps)!.click();
+
+        findDrawerHeaderActionById('add', renderProps)!.click();
+        expect(onHeaderActionClick).toHaveBeenCalledWith({ id: 'add' });
+      });
     });
 
     test('the order of the opened global drawers should match the positions of their corresponding toggle buttons on the toolbar', async () => {
@@ -1442,36 +1468,37 @@ describe('toolbar mode only features', () => {
 
           findDrawerTriggerById(drawerId, renderProps)!.click();
           expect(
-            globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.getElement()
+            renderProps.globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.getElement()
           ).toBeInTheDocument();
           expect(globalDrawersWrapper.findDrawerById(drawerId)!.isDrawerInExpandedMode()).toBe(false);
-          globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.click();
+          renderProps.globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.click();
           expect(globalDrawersWrapper.findDrawerById(drawerId)!.isDrawerInExpandedMode()).toBe(true);
+
           expect(
             getGeneratedAnalyticsMetadata(
-              globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.getElement()
+              renderProps.globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.getElement()
             )
           ).toEqual(
             expect.objectContaining({
               action: 'expand',
-              detail: {
+              detail: expect.objectContaining({
                 label: 'Expanded mode button',
-              },
+              }),
             })
           );
 
-          globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.click();
+          renderProps.globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.click();
           expect(globalDrawersWrapper.findDrawerById(drawerId)!.isDrawerInExpandedMode()).toBe(false);
           expect(
             getGeneratedAnalyticsMetadata(
-              globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.getElement()
+              renderProps.globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.getElement()
             )
           ).toEqual(
             expect.objectContaining({
               action: 'collapse',
-              detail: {
+              detail: expect.objectContaining({
                 label: 'Expanded mode button',
-              },
+              }),
             })
           );
         });
@@ -1545,10 +1572,10 @@ describe('toolbar mode only features', () => {
           await delay();
 
           findDrawerTriggerById(drawerId, renderProps)!.click();
-          globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.click();
+          renderProps.globalDrawersWrapper.findExpandedModeButtonByActiveDrawerId(drawerId)!.click();
           expect(globalDrawersWrapper.findDrawerById(drawerId)!.isDrawerInExpandedMode()).toBe(true);
           expect(globalDrawersWrapper.isLayoutInDrawerExpandedMode()).toBe(true);
-          globalDrawersWrapper.findCloseButtonByActiveDrawerId(drawerId)!.click();
+          renderProps.globalDrawersWrapper.findCloseButtonByActiveDrawerId(drawerId)!.click();
           expect(globalDrawersWrapper.isLayoutInDrawerExpandedMode()).toBe(false);
         });
       });
diff --git a/src/app-layout/__tests__/utils.tsx b/src/app-layout/__tests__/utils.tsx
index a52b6a6da7..9e8eb95fb2 100644
--- a/src/app-layout/__tests__/utils.tsx
+++ b/src/app-layout/__tests__/utils.tsx
@@ -12,7 +12,12 @@ import AppLayout, { AppLayoutProps } from '../../../lib/components/app-layout';
 import customCssProps from '../../../lib/components/internal/generated/custom-css-properties';
 import { forceMobileModeSymbol } from '../../../lib/components/internal/hooks/use-mobile';
 import { SplitPanelProps } from '../../../lib/components/split-panel';
-import createWrapper, { AppLayoutWrapper, ElementWrapper } from '../../../lib/components/test-utils/dom';
+import createWrapper, {
+  AppLayoutWrapper,
+  ButtonGroupWrapper,
+  ButtonWrapper,
+  ElementWrapper,
+} from '../../../lib/components/test-utils/dom';
 
 import testutilStyles from '../../../lib/components/app-layout/test-classes/styles.css.js';
 import visualRefreshStyles from '../../../lib/components/app-layout/visual-refresh/styles.css.js';
@@ -206,16 +211,22 @@ export const getGlobalDrawersTestUtils = (wrapper: AppLayoutWrapper) => {
       );
     },
 
-    findCloseButtonByActiveDrawerId(id: string): ElementWrapper | null {
-      return wrapper.find(
-        `.${testutilStyles['active-drawer']}[data-testid="awsui-app-layout-drawer-${id}"] .${testutilStyles['active-drawer-close-button']}`
-      );
+    findCloseButtonByActiveDrawerId(id: string): ButtonWrapper | null {
+      return wrapper
+        .findComponent(
+          `.${testutilStyles['active-drawer']}[data-testid="awsui-app-layout-drawer-${id}"]`,
+          ButtonGroupWrapper
+        )!
+        .findButtonById('close');
     },
 
-    findExpandedModeButtonByActiveDrawerId(id: string): ElementWrapper | null {
-      return wrapper.find(
-        `.${testutilStyles['active-drawer']}[data-testid="awsui-app-layout-drawer-${id}"] .${testutilStyles['active-drawer-expanded-mode-button']}`
-      );
+    findExpandedModeButtonByActiveDrawerId(id: string): ButtonWrapper | null {
+      return wrapper
+        .findComponent(
+          `.${testutilStyles['active-drawer']}[data-testid="awsui-app-layout-drawer-${id}"]`,
+          ButtonGroupWrapper
+        )!
+        .findButtonById('expand');
     },
 
     findLeaveExpandedModeButtonInAIDrawer(): ElementWrapper | null {
diff --git a/src/app-layout/runtime-drawer/index.tsx b/src/app-layout/runtime-drawer/index.tsx
index 2a40354c1c..0336991328 100644
--- a/src/app-layout/runtime-drawer/index.tsx
+++ b/src/app-layout/runtime-drawer/index.tsx
@@ -2,6 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 import React, { useContext, useEffect, useRef } from 'react';
 
+import { warnOnce } from '@cloudscape-design/component-toolkit/internal';
+
+import { ButtonGroupProps } from '../../button-group/interfaces';
 import { fireNonCancelableEvent, NonCancelableEventHandler } from '../../internal/events';
 import {
   DrawerConfig as RuntimeDrawerConfig,
@@ -79,11 +82,29 @@ function RuntimeDrawerHeader({ mountHeader, unmountHeader }: RuntimeContentHeade
   return <div className={styles['runtime-header-wrapper']} ref={ref} />;
 }
 
+function checkForUnsupportedProps(headerActions: ReadonlyArray<ButtonGroupProps.Item>) {
+  const unsupportedProps = new Set([
+    'iconSvg',
+    'popoverFeedback',
+    'pressedIconSvg',
+    'popoverFeedback',
+    'pressedPopoverFeedback',
+  ]);
+  for (const item of headerActions) {
+    const unsupported = Object.keys(item).filter(key => unsupportedProps.has(key));
+    if (unsupported.length > 0) {
+      warnOnce('AppLayout', `The headerActions properties are not supported for runtime api: ${unsupported.join(' ')}`);
+    }
+  }
+  return headerActions;
+}
+
 export const mapRuntimeConfigToDrawer = (
   runtimeConfig: RuntimeDrawerConfig
 ): AppLayoutProps.Drawer & {
   orderPriority?: number;
   onToggle?: NonCancelableEventHandler<DrawerStateChangeParams>;
+  headerActions?: ReadonlyArray<ButtonGroupProps.Item>;
 } => {
   const { mountContent, unmountContent, trigger, ...runtimeDrawer } = runtimeConfig;
 
@@ -111,6 +132,7 @@ export const mapRuntimeConfigToDrawer = (
     onResize: event => {
       fireNonCancelableEvent(runtimeDrawer.onResize, { size: event.detail.size, id: runtimeDrawer.id });
     },
+    headerActions: runtimeDrawer.headerActions ? checkForUnsupportedProps(runtimeDrawer.headerActions) : undefined,
   };
 };
 
@@ -119,6 +141,7 @@ export const mapRuntimeConfigToAiDrawer = (
 ): AppLayoutProps.Drawer & {
   orderPriority?: number;
   onToggle?: NonCancelableEventHandler<DrawerStateChangeParams>;
+  headerActions?: ReadonlyArray<ButtonGroupProps.Item>;
 } => {
   const { mountContent, unmountContent, trigger, ...runtimeDrawer } = runtimeConfig;
 
@@ -153,6 +176,7 @@ export const mapRuntimeConfigToAiDrawer = (
     onResize: event => {
       fireNonCancelableEvent(runtimeDrawer.onResize, { size: event.detail.size, id: runtimeDrawer.id });
     },
+    headerActions: runtimeDrawer.headerActions ? checkForUnsupportedProps(runtimeDrawer.headerActions) : undefined,
   };
 };
 
diff --git a/src/app-layout/visual-refresh-toolbar/drawer/global-ai-drawer.tsx b/src/app-layout/visual-refresh-toolbar/drawer/global-ai-drawer.tsx
index 7c37fa33bf..fc4ff30fba 100644
--- a/src/app-layout/visual-refresh-toolbar/drawer/global-ai-drawer.tsx
+++ b/src/app-layout/visual-refresh-toolbar/drawer/global-ai-drawer.tsx
@@ -4,7 +4,8 @@ import React, { useRef } from 'react';
 import { Transition } from 'react-transition-group';
 import clsx from 'clsx';
 
-import { InternalButton } from '../../../button/internal';
+import { InternalItemOrGroup } from '../../../button-group/interfaces';
+import ButtonGroup from '../../../button-group/internal';
 import PanelResizeHandle from '../../../internal/components/panel-resize-handle';
 import customCssProps from '../../../internal/generated/custom-css-properties';
 import { usePrevious } from '../../../internal/hooks/use-previous';
@@ -90,6 +91,37 @@ export function AppLayoutGlobalAiDrawerImplementation({
   // (window is between mobile and desktop sizes). At this point, the drawer can't be
   // resized in either direction, so we disable the resize handler
   const isResizingDisabled = maxAiDrawerSize < activeAiDrawerSize;
+  let drawerActions: ReadonlyArray<InternalItemOrGroup> = [
+    {
+      type: 'icon-button',
+      id: 'close',
+      iconName: isMobile ? 'close' : 'angle-left',
+      text: computedAriaLabels.closeButton,
+      analyticsAction: 'close',
+    },
+  ];
+  if (!isMobile && activeAiDrawer?.isExpandable) {
+    drawerActions = [
+      {
+        type: 'icon-button',
+        id: 'expand',
+        iconName: isExpanded ? 'shrink' : 'expand',
+        text: activeAiDrawer?.ariaLabels?.expandedModeButton ?? '',
+        analyticsAction: isExpanded ? 'expand' : 'collapse',
+      },
+      ...drawerActions,
+    ];
+  }
+  if (activeAiDrawer?.headerActions) {
+    drawerActions = [
+      {
+        type: 'group',
+        text: 'Actions',
+        items: activeAiDrawer.headerActions!,
+      },
+      ...drawerActions,
+    ];
+  }
 
   return (
     <Transition nodeRef={drawerRef} in={show} appear={show} mountOnEnter={true} timeout={250}>
@@ -152,34 +184,24 @@ export function AppLayoutGlobalAiDrawerImplementation({
                         <div className={styles['drawer-content-header-content']}>
                           {activeAiDrawer?.header ?? <div />}
                           <div className={styles['drawer-actions']}>
-                            {!isMobile && activeAiDrawer?.isExpandable && (
-                              <div className={styles['drawer-expanded-mode-button']}>
-                                <InternalButton
-                                  ariaLabel={activeAiDrawer?.ariaLabels?.expandedModeButton}
-                                  className={testutilStyles['active-drawer-expanded-mode-button']}
-                                  formAction="none"
-                                  ariaExpanded={isExpanded}
-                                  iconName={isExpanded ? 'shrink' : 'expand'}
-                                  onClick={() => setExpandedDrawerId(isExpanded ? null : activeDrawerId!)}
-                                  variant="icon"
-                                  analyticsAction={isExpanded ? 'expand' : 'collapse'}
-                                />
-                              </div>
-                            )}
-                            <div className={clsx(styles['drawer-close-button'])}>
-                              <InternalButton
-                                ariaLabel={computedAriaLabels.closeButton}
-                                className={clsx({
-                                  [testutilStyles['active-drawer-close-button']]: activeDrawerId,
-                                })}
-                                formAction="none"
-                                iconName={isMobile ? 'close' : 'angle-left'}
-                                onClick={() => onActiveAiDrawerChange?.(null, { initiatedByUserAction: true })}
-                                ref={aiDrawerFocusControl?.refs.close}
-                                variant="icon"
-                                analyticsAction="close"
-                              />
-                            </div>
+                            <ButtonGroup
+                              dropdownExpandToViewport={false}
+                              variant="icon"
+                              onItemClick={event => {
+                                switch (event.detail.id) {
+                                  case 'close':
+                                    onActiveAiDrawerChange?.(null, { initiatedByUserAction: true });
+                                    break;
+                                  case 'expand':
+                                    setExpandedDrawerId(isExpanded ? null : activeDrawerId!);
+                                    break;
+                                  default:
+                                    activeAiDrawer?.onHeaderActionClick?.(event);
+                                }
+                              }}
+                              ariaLabel="Left panel actions"
+                              items={drawerActions}
+                            />
                           </div>
                         </div>
                         {!isMobile && isExpanded && activeAiDrawer?.ariaLabels?.exitExpandedModeButton && (
diff --git a/src/app-layout/visual-refresh-toolbar/drawer/global-drawer.tsx b/src/app-layout/visual-refresh-toolbar/drawer/global-drawer.tsx
index 3acfa57ae4..27ed111208 100644
--- a/src/app-layout/visual-refresh-toolbar/drawer/global-drawer.tsx
+++ b/src/app-layout/visual-refresh-toolbar/drawer/global-drawer.tsx
@@ -4,11 +4,13 @@ import React, { useRef } from 'react';
 import { Transition } from 'react-transition-group';
 import clsx from 'clsx';
 
-import { InternalButton } from '../../../button/internal';
+import { InternalItemOrGroup } from '../../../button-group/interfaces';
+import ButtonGroup from '../../../button-group/internal';
 import PanelResizeHandle from '../../../internal/components/panel-resize-handle';
 import customCssProps from '../../../internal/generated/custom-css-properties';
 import { usePrevious } from '../../../internal/hooks/use-previous';
 import { getLimitedValue } from '../../../split-panel/utils/size-utils';
+import { Focusable } from '../../utils/use-focus-control';
 import { getDrawerStyles } from '../compute-layout';
 import { AppLayoutInternals, InternalDrawer } from '../interfaces';
 import { useResize } from './use-resize';
@@ -74,6 +76,37 @@ function AppLayoutGlobalDrawerImplementation({
   const animationDisabled =
     (activeGlobalDrawer?.defaultActive && !drawersOpenQueue.includes(activeGlobalDrawer.id)) ||
     (wasExpanded && !isExpanded);
+  let drawerActions: ReadonlyArray<InternalItemOrGroup> = [
+    {
+      type: 'icon-button',
+      id: 'close',
+      iconName: isMobile ? 'close' : 'angle-right',
+      text: computedAriaLabels.closeButton ?? '',
+      analyticsAction: 'close',
+    },
+  ];
+  if (!isMobile && activeGlobalDrawer?.isExpandable) {
+    drawerActions = [
+      {
+        type: 'icon-button',
+        id: 'expand',
+        iconName: isExpanded ? 'shrink' : 'expand',
+        text: activeGlobalDrawer?.ariaLabels?.expandedModeButton ?? '',
+        analyticsAction: isExpanded ? 'expand' : 'collapse',
+      },
+      ...drawerActions,
+    ];
+  }
+  if (activeGlobalDrawer?.headerActions) {
+    drawerActions = [
+      {
+        type: 'group',
+        text: 'Actions',
+        items: activeGlobalDrawer.headerActions!,
+      },
+      ...drawerActions,
+    ];
+  }
 
   return (
     <Transition nodeRef={drawerRef} in={show || isExpanded} appear={show || isExpanded} timeout={0}>
@@ -146,34 +179,30 @@ function AppLayoutGlobalDrawerImplementation({
                 data-testid={`awsui-app-layout-drawer-content-${activeDrawerId}`}
               >
                 <div className={styles['drawer-actions']}>
-                  {!isMobile && activeGlobalDrawer?.isExpandable && (
-                    <div className={styles['drawer-expanded-mode-button']}>
-                      <InternalButton
-                        ariaLabel={activeGlobalDrawer?.ariaLabels?.expandedModeButton}
-                        className={testutilStyles['active-drawer-expanded-mode-button']}
-                        formAction="none"
-                        ariaExpanded={isExpanded}
-                        iconName={isExpanded ? 'shrink' : 'expand'}
-                        onClick={() => setExpandedDrawerId(isExpanded ? null : activeDrawerId)}
-                        variant="icon"
-                        analyticsAction={isExpanded ? 'expand' : 'collapse'}
-                      />
-                    </div>
-                  )}
-                  <div className={clsx(styles['drawer-close-button'])}>
-                    <InternalButton
-                      ariaLabel={computedAriaLabels.closeButton}
-                      className={clsx({
-                        [testutilStyles['active-drawer-close-button']]: activeDrawerId,
-                      })}
-                      formAction="none"
-                      iconName={isMobile ? 'close' : 'angle-right'}
-                      onClick={() => onActiveGlobalDrawersChange(activeDrawerId, { initiatedByUserAction: true })}
-                      ref={refs?.close}
-                      variant="icon"
-                      analyticsAction="close"
-                    />
-                  </div>
+                  <ButtonGroup
+                    dropdownExpandToViewport={false}
+                    variant="icon"
+                    onItemClick={event => {
+                      switch (event.detail.id) {
+                        case 'close':
+                          onActiveGlobalDrawersChange(activeDrawerId, { initiatedByUserAction: true });
+                          break;
+                        case 'expand':
+                          setExpandedDrawerId(isExpanded ? null : activeDrawerId);
+                          break;
+                        default:
+                          activeGlobalDrawer?.onHeaderActionClick?.(event);
+                      }
+                    }}
+                    ariaLabel="Global panel actions"
+                    items={drawerActions}
+                    __internalRootRef={(root: HTMLElement) => {
+                      if (!root) {
+                        return;
+                      }
+                      refs.close = { current: root.querySelector('[data-itemid="close"]') as unknown as Focusable };
+                    }}
+                  />
                 </div>
                 <div className={styles['drawer-content']} style={{ blockSize: drawerHeight }}>
                   {activeGlobalDrawer?.content}
diff --git a/src/app-layout/visual-refresh-toolbar/interfaces.ts b/src/app-layout/visual-refresh-toolbar/interfaces.ts
index 509ba31cfa..968a690e95 100644
--- a/src/app-layout/visual-refresh-toolbar/interfaces.ts
+++ b/src/app-layout/visual-refresh-toolbar/interfaces.ts
@@ -4,7 +4,9 @@
 import React from 'react';
 
 import { BreadcrumbGroupProps } from '../../breadcrumb-group/interfaces';
+import { ButtonGroupProps } from '../../button-group/interfaces';
 import { SplitPanelSideToggleProps } from '../../internal/context/split-panel-context';
+import { NonCancelableEventHandler } from '../../internal/events';
 import { SomeOptional } from '../../internal/types';
 import { AppLayoutProps, AppLayoutPropsWithDefaults } from '../interfaces';
 import { SplitPanelProviderProps } from '../split-panel';
@@ -22,6 +24,8 @@ export type InternalDrawer = AppLayoutProps.Drawer & {
   isExpandable?: boolean;
   ariaLabels: AppLayoutProps.Drawer['ariaLabels'] & { expandedModeButton?: string; exitExpandedModeButton?: string };
   header?: React.ReactNode;
+  headerActions?: ReadonlyArray<ButtonGroupProps.Item>;
+  onHeaderActionClick?: NonCancelableEventHandler<ButtonGroupProps.ItemClickDetails>;
 };
 
 // Widgetization notice: structures in this file are shared multiple app layout instances, possibly different minor versions.
diff --git a/src/button-group/icon-button-item.tsx b/src/button-group/icon-button-item.tsx
index 9b7040b5da..4a2861f141 100644
--- a/src/button-group/icon-button-item.tsx
+++ b/src/button-group/icon-button-item.tsx
@@ -10,12 +10,12 @@ import { InternalButton } from '../button/internal.js';
 import Tooltip from '../internal/components/tooltip/index.js';
 import { CancelableEventHandler, fireCancelableEvent } from '../internal/events/index.js';
 import InternalLiveRegion from '../live-region/internal.js';
-import { ButtonGroupProps } from './interfaces.js';
+import { ButtonGroupProps, InternalIconButton } from './interfaces.js';
 
 import testUtilStyles from './test-classes/styles.css.js';
 
 interface IconButtonItemProps {
-  item: ButtonGroupProps.IconButton;
+  item: InternalIconButton;
   showTooltip: boolean;
   showFeedback: boolean;
   onTooltipDismiss: () => void;
@@ -55,6 +55,7 @@ const IconButtonItem = forwardRef(
           data-testid={item.id}
           data-itemid={item.id}
           className={clsx(testUtilStyles.item, testUtilStyles['button-group-item'])}
+          analyticsAction={item.analyticsAction}
           __title=""
         >
           {item.text}
diff --git a/src/button-group/interfaces.ts b/src/button-group/interfaces.ts
index 02c327a689..00d434c8eb 100644
--- a/src/button-group/interfaces.ts
+++ b/src/button-group/interfaces.ts
@@ -105,10 +105,22 @@ export interface ButtonGroupProps extends BaseComponentProps {
   style?: ButtonGroupProps.Style;
 }
 
+export interface InternalIconButton extends ButtonGroupProps.IconButton {
+  analyticsAction?: string;
+}
+
+export type InternalItemOrGroup = InternalItem | ButtonGroupProps.Group;
+export type InternalItem =
+  | InternalIconButton
+  | ButtonGroupProps.IconToggleButton
+  | ButtonGroupProps.IconFileInput
+  | ButtonGroupProps.MenuDropdown;
+
 export interface InternalButtonGroupProps
   extends SomeRequired<ButtonGroupProps, 'dropdownExpandToViewport'>,
     InternalBaseComponentProps {
   style?: ButtonGroupProps.Style;
+  items: ReadonlyArray<InternalItemOrGroup>;
 }
 
 export namespace ButtonGroupProps {
diff --git a/src/internal/plugins/controllers/drawers.ts b/src/internal/plugins/controllers/drawers.ts
index ecc9d3058f..87d4c20473 100644
--- a/src/internal/plugins/controllers/drawers.ts
+++ b/src/internal/plugins/controllers/drawers.ts
@@ -1,5 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+import { ButtonGroupProps } from '../../../button-group/interfaces';
 import debounce from '../../debounce';
 import { NonCancelableEventHandler } from '../../events';
 import { reportRuntimeApiWarning } from '../helpers/metrics';
@@ -40,6 +41,8 @@ export interface DrawerConfig {
   unmountContent: (container: HTMLElement) => void;
   preserveInactiveContent?: boolean;
   onToggle?: NonCancelableEventHandler<DrawerStateChangeParams>;
+  headerActions?: ReadonlyArray<ButtonGroupProps.Item>;
+  onHeaderActionClick?: NonCancelableEventHandler<ButtonGroupProps.ItemClickDetails>;
 }
 
 const updatableProperties = [
diff --git a/src/internal/plugins/widget/interfaces.ts b/src/internal/plugins/widget/interfaces.ts
index 3c3f00fc1b..24a4c870a8 100644
--- a/src/internal/plugins/widget/interfaces.ts
+++ b/src/internal/plugins/widget/interfaces.ts
@@ -1,5 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+import { ButtonGroupProps } from '../../../button-group/interfaces';
 import { NonCancelableEventHandler } from '../../events';
 
 interface Message<Type, Payload> {
@@ -44,6 +45,8 @@ export interface DrawerPayload {
   onToggle?: NonCancelableEventHandler<DrawerStateChangeParams>;
   mountHeader?: (container: HTMLElement) => void;
   unmountHeader?: (container: HTMLElement) => void;
+  headerActions?: ReadonlyArray<ButtonGroupProps.Item>;
+  onHeaderActionClick?: NonCancelableEventHandler<ButtonGroupProps.ItemClickDetails>;
 }
 
 export type RegisterDrawerMessage = Message<'registerLeftDrawer', DrawerPayload>;

From d5b41ab430a246181ceb9379c0b28c898d75e3c2 Mon Sep 17 00:00:00 2001
From: Andrei Zhaleznichenka <zhalea@amazon.de>
Date: Tue, 9 Sep 2025 18:49:36 +0200
Subject: [PATCH 09/32] chore: Uses updated stsn testing utils (#3850)

---
 src/button/__tests__/button.test.tsx          | 27 ++++++++++++-------
 src/checkbox/__tests__/checkbox.test.tsx      | 27 ++++++++++++-------
 src/link/__tests__/index.test.tsx             | 25 ++++++++++++-----
 src/popover/__tests__/popover.test.tsx        | 27 ++++++++++++-------
 .../__tests__/radio-group.test.tsx            | 21 +++++++++------
 src/table/__tests__/body-cell.test.tsx        | 15 ++++++++---
 src/table/__tests__/header-cell.test.tsx      | 17 +++++++-----
 7 files changed, 104 insertions(+), 55 deletions(-)

diff --git a/src/button/__tests__/button.test.tsx b/src/button/__tests__/button.test.tsx
index c3124a79cb..4d3f62edfe 100644
--- a/src/button/__tests__/button.test.tsx
+++ b/src/button/__tests__/button.test.tsx
@@ -4,7 +4,10 @@ import React from 'react';
 import { act, fireEvent, render } from '@testing-library/react';
 
 import { clearMessageCache } from '@cloudscape-design/component-toolkit/internal';
-import { renderWithSingleTabStopNavigation } from '@cloudscape-design/component-toolkit/internal/testing';
+import {
+  setTestSingleTabStopNavigationTarget,
+  TestSingleTabStopNavigationProvider,
+} from '@cloudscape-design/component-toolkit/internal/testing';
 
 import Button, { ButtonProps } from '../../../lib/components/button';
 import InternalButton from '../../../lib/components/button/internal';
@@ -811,30 +814,34 @@ describe('table grid navigation support', () => {
   }
 
   test('does not override tab index when keyboard navigation is not active', () => {
-    renderWithSingleTabStopNavigation(<Button id="button" />, { navigationActive: false });
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={false}>
+        <Button id="button" />
+      </TestSingleTabStopNavigationProvider>
+    );
     expect(getButton('#button')).not.toHaveAttribute('tabIndex');
   });
 
   test('overrides tab index when keyboard navigation is active', () => {
-    const { setCurrentTarget } = renderWithSingleTabStopNavigation(
-      <div>
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={true}>
         <Button id="button1" />
         <Button id="button2" />
-      </div>
+      </TestSingleTabStopNavigationProvider>
     );
-    setCurrentTarget(getButton('#button1'));
+    setTestSingleTabStopNavigationTarget(getButton('#button1'));
     expect(getButton('#button1')).toHaveAttribute('tabIndex', '0');
     expect(getButton('#button2')).toHaveAttribute('tabIndex', '-1');
   });
 
   test('does not override explicit tab index with 0', () => {
-    const { setCurrentTarget } = renderWithSingleTabStopNavigation(
-      <div>
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={true}>
         <InternalButton id="button1" nativeButtonAttributes={{ tabIndex: -2 }} />
         <InternalButton id="button2" nativeButtonAttributes={{ tabIndex: -2 }} />
-      </div>
+      </TestSingleTabStopNavigationProvider>
     );
-    setCurrentTarget(getButton('#button1'));
+    setTestSingleTabStopNavigationTarget(getButton('#button1'));
     expect(getButton('#button1')).toHaveAttribute('tabIndex', '-2');
     expect(getButton('#button2')).toHaveAttribute('tabIndex', '-2');
   });
diff --git a/src/checkbox/__tests__/checkbox.test.tsx b/src/checkbox/__tests__/checkbox.test.tsx
index 7912f158cc..6020cb5d68 100644
--- a/src/checkbox/__tests__/checkbox.test.tsx
+++ b/src/checkbox/__tests__/checkbox.test.tsx
@@ -3,7 +3,10 @@
 import React, { useState } from 'react';
 import { render } from '@testing-library/react';
 
-import { renderWithSingleTabStopNavigation } from '@cloudscape-design/component-toolkit/internal/testing';
+import {
+  setTestSingleTabStopNavigationTarget,
+  TestSingleTabStopNavigationProvider,
+} from '@cloudscape-design/component-toolkit/internal/testing';
 
 import Checkbox, { CheckboxProps } from '../../../lib/components/checkbox';
 import InternalCheckbox from '../../../lib/components/checkbox/internal';
@@ -243,30 +246,34 @@ describe('table grid navigation support', () => {
   }
 
   test('does not override tab index when keyboard navigation is not active', () => {
-    renderWithSingleTabStopNavigation(<Checkbox id="checkbox" checked={false} />, { navigationActive: false });
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={false}>
+        <Checkbox id="checkbox" checked={false} />
+      </TestSingleTabStopNavigationProvider>
+    );
     expect(getCheckboxInput('#checkbox')).not.toHaveAttribute('tabIndex');
   });
 
   test('overrides tab index when keyboard navigation is active', () => {
-    const { setCurrentTarget } = renderWithSingleTabStopNavigation(
-      <div>
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={true}>
         <Checkbox id="checkbox1" checked={false} />
         <Checkbox id="checkbox2" checked={false} />
-      </div>
+      </TestSingleTabStopNavigationProvider>
     );
-    setCurrentTarget(getCheckboxInput('#checkbox1'));
+    setTestSingleTabStopNavigationTarget(getCheckboxInput('#checkbox1'));
     expect(getCheckboxInput('#checkbox1')).toHaveAttribute('tabIndex', '0');
     expect(getCheckboxInput('#checkbox2')).toHaveAttribute('tabIndex', '-1');
   });
 
   test('does not override explicit tab index with 0', () => {
-    const { setCurrentTarget } = renderWithSingleTabStopNavigation(
-      <div>
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={true}>
         <InternalCheckbox id="checkbox1" checked={false} tabIndex={-1} />
         <InternalCheckbox id="checkbox2" checked={false} tabIndex={-1} />
-      </div>
+      </TestSingleTabStopNavigationProvider>
     );
-    setCurrentTarget(getCheckboxInput('#checkbox1'));
+    setTestSingleTabStopNavigationTarget(getCheckboxInput('#checkbox1'));
     expect(getCheckboxInput('#checkbox1')).toHaveAttribute('tabIndex', '-1');
     expect(getCheckboxInput('#checkbox2')).toHaveAttribute('tabIndex', '-1');
   });
diff --git a/src/link/__tests__/index.test.tsx b/src/link/__tests__/index.test.tsx
index 996234d020..4b92151b9b 100644
--- a/src/link/__tests__/index.test.tsx
+++ b/src/link/__tests__/index.test.tsx
@@ -3,7 +3,10 @@
 import React from 'react';
 import { act, render } from '@testing-library/react';
 
-import { renderWithSingleTabStopNavigation } from '@cloudscape-design/component-toolkit/internal/testing';
+import {
+  setTestSingleTabStopNavigationTarget,
+  TestSingleTabStopNavigationProvider,
+} from '@cloudscape-design/component-toolkit/internal/testing';
 import { KeyCode } from '@cloudscape-design/test-utils-core/utils';
 
 import FormField from '../../../lib/components/form-field';
@@ -285,23 +288,31 @@ describe('table grid navigation support', () => {
   }
 
   test('does not override tab index for button link when keyboard navigation is not active', () => {
-    renderWithSingleTabStopNavigation(<Link id="link" />, { navigationActive: false });
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={false}>
+        <Link id="link" />
+      </TestSingleTabStopNavigationProvider>
+    );
     expect(getLink('#link')).toHaveAttribute('tabIndex', '0');
   });
 
   test('does not override tab index for anchor link when keyboard navigation is not active', () => {
-    renderWithSingleTabStopNavigation(<Link id="link" href="#" />, { navigationActive: false });
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={false}>
+        <Link id="link" href="#" />
+      </TestSingleTabStopNavigationProvider>
+    );
     expect(getLink('#link')).not.toHaveAttribute('tabIndex');
   });
 
   test.each([undefined, '#'])('overrides tab index when keyboard navigation is active href=%s', href => {
-    const { setCurrentTarget } = renderWithSingleTabStopNavigation(
-      <div>
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={true}>
         <Link id="link1" href={href} />
         <Link id="link2" href={href} />
-      </div>
+      </TestSingleTabStopNavigationProvider>
     );
-    setCurrentTarget(getLink('#link1'));
+    setTestSingleTabStopNavigationTarget(getLink('#link1'));
     expect(getLink('#link1')).toHaveAttribute('tabIndex', '0');
     expect(getLink('#link2')).toHaveAttribute('tabIndex', '-1');
   });
diff --git a/src/popover/__tests__/popover.test.tsx b/src/popover/__tests__/popover.test.tsx
index e129bbfd79..daf786f83f 100644
--- a/src/popover/__tests__/popover.test.tsx
+++ b/src/popover/__tests__/popover.test.tsx
@@ -3,7 +3,10 @@
 import React from 'react';
 import { act, render } from '@testing-library/react';
 
-import { renderWithSingleTabStopNavigation } from '@cloudscape-design/component-toolkit/internal/testing';
+import {
+  setTestSingleTabStopNavigationTarget,
+  TestSingleTabStopNavigationProvider,
+} from '@cloudscape-design/component-toolkit/internal/testing';
 import { KeyCode } from '@cloudscape-design/test-utils-core/utils';
 
 import '../../__a11y__/to-validate-a11y';
@@ -366,29 +369,33 @@ describe('table grid navigation support', () => {
   }
 
   test('does not override tab index when keyboard navigation is not active', () => {
-    renderWithSingleTabStopNavigation(<Popover>Trigger</Popover>, { navigationActive: false });
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={false}>
+        <Popover>Trigger</Popover>
+      </TestSingleTabStopNavigationProvider>
+    );
     expect(getTrigger()).not.toHaveAttribute('tabIndex');
   });
 
   test('overrides tab index when keyboard navigation is active', () => {
-    const { setCurrentTarget } = renderWithSingleTabStopNavigation(
-      <div>
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={true}>
         <Popover id="popover1">Trigger</Popover>
         <Popover id="popover2">Trigger</Popover>
-      </div>
+      </TestSingleTabStopNavigationProvider>
     );
-    setCurrentTarget(getTrigger('#popover1'));
+    setTestSingleTabStopNavigationTarget(getTrigger('#popover1'));
     expect(getTrigger('#popover1')).toHaveAttribute('tabIndex', '0');
     expect(getTrigger('#popover2')).toHaveAttribute('tabIndex', '-1');
   });
 
   test('does not override tab index for custom trigger', () => {
-    const { setCurrentTarget } = renderWithSingleTabStopNavigation(
-      <div>
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={true}>
         <Popover triggerType="custom">Trigger</Popover>
-      </div>
+      </TestSingleTabStopNavigationProvider>
     );
-    setCurrentTarget(getTrigger());
+    setTestSingleTabStopNavigationTarget(getTrigger());
     expect(getTrigger()).not.toHaveAttribute('tabIndex');
   });
 });
diff --git a/src/radio-group/__tests__/radio-group.test.tsx b/src/radio-group/__tests__/radio-group.test.tsx
index 662c82b8ec..14e707c30b 100644
--- a/src/radio-group/__tests__/radio-group.test.tsx
+++ b/src/radio-group/__tests__/radio-group.test.tsx
@@ -3,7 +3,10 @@
 import React, { useState } from 'react';
 import { act, render } from '@testing-library/react';
 
-import { renderWithSingleTabStopNavigation } from '@cloudscape-design/component-toolkit/internal/testing';
+import {
+  setTestSingleTabStopNavigationTarget,
+  TestSingleTabStopNavigationProvider,
+} from '@cloudscape-design/component-toolkit/internal/testing';
 
 import '../../__a11y__/to-validate-a11y';
 import RadioGroup, { RadioGroupProps } from '../../../lib/components/radio-group';
@@ -369,20 +372,22 @@ describe('table grid navigation support', () => {
   }
 
   test('does not override tab index when keyboard navigation is not active', () => {
-    renderWithSingleTabStopNavigation(<RadioGroup id="radio" value={null} items={[{ value: '1', label: 'One' }]} />, {
-      navigationActive: false,
-    });
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={false}>
+        <RadioGroup id="radio" value={null} items={[{ value: '1', label: 'One' }]} />
+      </TestSingleTabStopNavigationProvider>
+    );
     expect(getRadioInput('#radio')).not.toHaveAttribute('tabIndex');
   });
 
   test('overrides tab index when keyboard navigation is active', () => {
-    const { setCurrentTarget } = renderWithSingleTabStopNavigation(
-      <div>
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={true}>
         <RadioGroup id="radio1" value={null} items={[{ value: '1', label: 'One' }]} />
         <RadioGroup id="radio2" value={null} items={[{ value: '2', label: 'Two' }]} />
-      </div>
+      </TestSingleTabStopNavigationProvider>
     );
-    setCurrentTarget(getRadioInput('#radio1'));
+    setTestSingleTabStopNavigationTarget(getRadioInput('#radio1'));
     expect(getRadioInput('#radio1')).toHaveAttribute('tabIndex', '0');
     expect(getRadioInput('#radio2')).toHaveAttribute('tabIndex', '-1');
   });
diff --git a/src/table/__tests__/body-cell.test.tsx b/src/table/__tests__/body-cell.test.tsx
index 9b5e62c88c..5101175c37 100644
--- a/src/table/__tests__/body-cell.test.tsx
+++ b/src/table/__tests__/body-cell.test.tsx
@@ -3,7 +3,10 @@
 import * as React from 'react';
 import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 
-import { renderWithSingleTabStopNavigation } from '@cloudscape-design/component-toolkit/internal/testing';
+import {
+  setTestSingleTabStopNavigationTarget,
+  TestSingleTabStopNavigationProvider,
+} from '@cloudscape-design/component-toolkit/internal/testing';
 
 import { LiveRegionController } from '../../../lib/components/live-region/controller.js';
 import { TableBodyCell, TableBodyCellProps } from '../../../lib/components/table/body-cell';
@@ -336,13 +339,17 @@ describe('TableBodyCell', () => {
   });
 
   test('does not set tab index when negative', () => {
-    const { setCurrentTarget } = renderWithSingleTabStopNavigation(<TestComponent />, { navigationActive: true });
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={true}>
+        <TestComponent />
+      </TestSingleTabStopNavigationProvider>
+    );
     const tableCell = wrapper().find('td')!.getElement();
 
     expect(tableCell).not.toHaveAttribute('tabIndex');
-    setCurrentTarget(tableCell);
+    setTestSingleTabStopNavigationTarget(tableCell);
     expect(tableCell).toHaveAttribute('tabIndex', '0');
-    setCurrentTarget(null);
+    setTestSingleTabStopNavigationTarget(null);
     expect(tableCell).not.toHaveAttribute('tabIndex');
   });
 
diff --git a/src/table/__tests__/header-cell.test.tsx b/src/table/__tests__/header-cell.test.tsx
index f22c1c47b9..a525db2467 100644
--- a/src/table/__tests__/header-cell.test.tsx
+++ b/src/table/__tests__/header-cell.test.tsx
@@ -4,7 +4,10 @@ import * as React from 'react';
 import { fireEvent, render } from '@testing-library/react';
 
 import { ContainerQueryEntry } from '@cloudscape-design/component-toolkit';
-import { renderWithSingleTabStopNavigation } from '@cloudscape-design/component-toolkit/internal/testing';
+import {
+  setTestSingleTabStopNavigationTarget,
+  TestSingleTabStopNavigationProvider,
+} from '@cloudscape-design/component-toolkit/internal/testing';
 
 import TestI18nProvider from '../../../lib/components/i18n/testing';
 import { TableHeaderCell, TableHeaderCellProps } from '../../../lib/components/table/header-cell';
@@ -124,15 +127,17 @@ describe('i18n', () => {
   });
 
   test('does not set tab index when negative', () => {
-    const { setCurrentTarget } = renderWithSingleTabStopNavigation(<TestComponent />, {
-      navigationActive: true,
-    });
+    render(
+      <TestSingleTabStopNavigationProvider navigationActive={true}>
+        <TestComponent />
+      </TestSingleTabStopNavigationProvider>
+    );
     const headerCell = document.querySelector('th')!;
 
     expect(headerCell).not.toHaveAttribute('tabIndex');
-    setCurrentTarget(headerCell);
+    setTestSingleTabStopNavigationTarget(headerCell);
     expect(headerCell).toHaveAttribute('tabIndex', '0');
-    setCurrentTarget(null);
+    setTestSingleTabStopNavigationTarget(null);
     expect(headerCell).not.toHaveAttribute('tabIndex');
   });
 });

From 562af68da7f01b2794da599044c26e1f8d3f5efa Mon Sep 17 00:00:00 2001
From: Avinash Dwarapu <dwaraa@amazon.com>
Date: Wed, 10 Sep 2025 12:00:39 +0200
Subject: [PATCH 10/32] fix: Allow interactive elements to be placed inside key
 of a key-value pair (#3845)

---
 src/key-value-pairs/internal.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/key-value-pairs/internal.tsx b/src/key-value-pairs/internal.tsx
index efe5e276b8..318a8ff02b 100644
--- a/src/key-value-pairs/internal.tsx
+++ b/src/key-value-pairs/internal.tsx
@@ -19,9 +19,9 @@ const InternalKeyValuePair = ({ label, info, value, id }: KeyValuePairsProps.Pai
   return (
     <>
       <dt className={styles.term}>
-        <label className={styles['key-label']} id={id || kvPairId}>
+        <div className={styles['key-label']} id={id || kvPairId}>
           {label}
-        </label>
+        </div>
         <InfoLinkLabelContext.Provider value={id || kvPairId}>
           {info && <span className={styles.info}>{info}</span>}
         </InfoLinkLabelContext.Provider>

From 50ebf3c0593aaacbe923d38dd89265e0e5a19bd6 Mon Sep 17 00:00:00 2001
From: Andrei Zhaleznichenka <zhalea@amazon.de>
Date: Wed, 10 Sep 2025 14:26:00 +0200
Subject: [PATCH 11/32] chore: Fixes funnel integ tests with React 18 strict
 mode (#3852)

---
 .../analytics/components/analytics-funnel.tsx | 10 +++++++---
 src/internal/components/focus-lock/index.tsx  | 20 +++++++++++--------
 2 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/src/internal/analytics/components/analytics-funnel.tsx b/src/internal/analytics/components/analytics-funnel.tsx
index b8af559d87..158f0f5c97 100644
--- a/src/internal/analytics/components/analytics-funnel.tsx
+++ b/src/internal/analytics/components/analytics-funnel.tsx
@@ -182,12 +182,16 @@ const InnerAnalyticsFunnel = ({ mounted = true, children, stepConfiguration, ...
       setFunnelInteractionId(funnelInteractionId);
     }, 1);
 
-    /*
-      A funnel counts as "successful" if it is unmounted after being "complete".
-    */
+    // A funnel counts as "successful" if it is unmounted after being "complete".
     /* eslint-disable react-hooks/exhaustive-deps */
     return () => {
       clearTimeout(handle);
+
+      // There is no need in cleanup if the funnel was not started.
+      if (!funnelInteractionId) {
+        return;
+      }
+
       if (props.funnelType === 'single-page' && wizardCount.current > 0) {
         return;
       }
diff --git a/src/internal/components/focus-lock/index.tsx b/src/internal/components/focus-lock/index.tsx
index 06ab0a6b7a..39f958baf9 100644
--- a/src/internal/components/focus-lock/index.tsx
+++ b/src/internal/components/focus-lock/index.tsx
@@ -26,7 +26,7 @@ function FocusLock(
   { className, disabled, autoFocus, restoreFocus, children }: FocusLockProps,
   ref: React.Ref<FocusLockRef>
 ) {
-  const returnFocusToRef = useRef<HTMLOrSVGElement | null>(null);
+  const restoreFocusTargetRef = useRef<HTMLOrSVGElement | null>(null);
   const containerRef = useRef<HTMLDivElement | null>(null);
 
   const focusFirst = () => {
@@ -44,21 +44,25 @@ function FocusLock(
   // Captures focus when `autoFocus` is set, and the component is mounted or
   // `disabled` changes from true to false.
   useEffect(() => {
+    const assignRestoreFocusTarget = () => {
+      if (document.activeElement && !containerRef.current?.contains(document.activeElement as Node)) {
+        restoreFocusTargetRef.current = document.activeElement as unknown as HTMLOrSVGElement;
+      }
+    };
     if (autoFocus && !disabled) {
-      returnFocusToRef.current = document.activeElement as HTMLOrSVGElement | null;
+      assignRestoreFocusTarget();
       focusFirst();
     }
   }, [autoFocus, disabled]);
 
-  // Restore focus if `restoreFocus` is set, and `disabled` changes from false
-  // to true.
+  // Restore focus if `restoreFocus` is set, and `disabled` changes from false to true.
   const [previouslyDisabled, setPreviouslyDisabled] = useState(!!disabled);
   useEffect(() => {
     if (previouslyDisabled !== !!disabled) {
       setPreviouslyDisabled(!!disabled);
       if (restoreFocus && disabled) {
-        returnFocusToRef.current?.focus();
-        returnFocusToRef.current = null;
+        restoreFocusTargetRef.current?.focus();
+        restoreFocusTargetRef.current = null;
       }
     }
   }, [previouslyDisabled, disabled, restoreFocus]);
@@ -68,8 +72,8 @@ function FocusLock(
   const restoreFocusHandler = useCallback(
     (elem: HTMLDivElement | null) => {
       if (elem === null && restoreFocus) {
-        returnFocusToRef.current?.focus();
-        returnFocusToRef.current = null;
+        restoreFocusTargetRef.current?.focus();
+        restoreFocusTargetRef.current = null;
       }
     },
     [restoreFocus]

From e0664dfeb1717e3329e719c69fb5b83fe1360f5a Mon Sep 17 00:00:00 2001
From: Avinash Dwarapu <dwaraa@amazon.com>
Date: Wed, 10 Sep 2025 15:31:01 +0200
Subject: [PATCH 12/32] fix: Ensure scroll position is on the file input button
 when focused (#3847)

---
 pages/file-input/integ.page.tsx             | 32 ++++++++++++++
 src/file-input/__integ__/file-input.test.ts | 47 +++++++++++++++++++++
 src/file-input/internal.tsx                 |  1 -
 src/file-input/styles.scss                  | 22 +++++++---
 4 files changed, 96 insertions(+), 6 deletions(-)
 create mode 100644 pages/file-input/integ.page.tsx
 create mode 100644 src/file-input/__integ__/file-input.test.ts

diff --git a/pages/file-input/integ.page.tsx b/pages/file-input/integ.page.tsx
new file mode 100644
index 0000000000..b7ae0197d2
--- /dev/null
+++ b/pages/file-input/integ.page.tsx
@@ -0,0 +1,32 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import React, { useState } from 'react';
+
+import { Box, FileInput, FileInputProps } from '~components';
+
+import ScreenshotArea from '../utils/screenshot-area';
+
+export default function DateInputScenario() {
+  const [files, setFiles] = useState<File[]>([]);
+
+  const ref = React.useRef<FileInputProps.Ref>(null);
+
+  return (
+    <ScreenshotArea>
+      <Box padding="l">
+        <h1>File input</h1>
+        <button id="focus-before">Click here</button>
+        <div style={{ paddingBlock: 2000 }}>
+          <FileInput ref={ref} multiple={true} value={files} onChange={event => setFiles(event.detail.value)}>
+            Choose files
+          </FileInput>
+          <button id="focus-after">Click here</button>
+
+          {files.map((file, index) => (
+            <div key={index}>{file.name}</div>
+          ))}
+        </div>
+      </Box>
+    </ScreenshotArea>
+  );
+}
diff --git a/src/file-input/__integ__/file-input.test.ts b/src/file-input/__integ__/file-input.test.ts
new file mode 100644
index 0000000000..2e587c57f8
--- /dev/null
+++ b/src/file-input/__integ__/file-input.test.ts
@@ -0,0 +1,47 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { BasePageObject } from '@cloudscape-design/browser-test-tools/page-objects';
+import useBrowser from '@cloudscape-design/browser-test-tools/use-browser';
+
+import createWrapper from '../../../lib/components/test-utils/selectors';
+
+const wrapper = createWrapper();
+const fileInputWrapper = wrapper.findFileInput();
+
+const setupTest = (testFn: (page: BasePageObject) => Promise<void>) => {
+  return useBrowser(async browser => {
+    const page = new BasePageObject(browser);
+    await browser.url('#/light/file-input/integ');
+    await page.waitForVisible(fileInputWrapper.toSelector());
+    await testFn(page);
+  });
+};
+
+describe('FileInput', () => {
+  test(
+    'visible in viewport when input is focused',
+    setupTest(async page => {
+      await page.click('#focus-before');
+      await page.keys(['Tab']);
+
+      // Check that the file input is still in the viewport
+      await expect(page.isDisplayedInViewport(fileInputWrapper.findTrigger().toSelector())).resolves.toBe(true);
+    })
+  );
+
+  test(
+    'does not scroll the page if the button is already visible',
+    setupTest(async page => {
+      await page.click('#focus-before');
+      await page.keys(['Tab']);
+      const beforeScrollPosition = await page.getWindowScroll();
+
+      await page.click('#focus-after');
+      await page.keys(['Shift', 'Tab']);
+      const afterScrollPosition = await page.getWindowScroll();
+
+      // Check that the positions are the same
+      expect(beforeScrollPosition).toStrictEqual(afterScrollPosition);
+    })
+  );
+});
diff --git a/src/file-input/internal.tsx b/src/file-input/internal.tsx
index 7c14453c15..31e1c0b66c 100644
--- a/src/file-input/internal.tsx
+++ b/src/file-input/internal.tsx
@@ -66,7 +66,6 @@ const InternalFileInput = React.forwardRef(
     const onUploadButtonClick = () => uploadInputRef.current?.click();
     const onUploadInputFocus = () => {
       setIsFocused(true);
-      containerRef.current?.scrollIntoView?.();
     };
     const onUploadInputBlur = () => setIsFocused(false);
 
diff --git a/src/file-input/styles.scss b/src/file-input/styles.scss
index 4fd64c68a2..9abde0625d 100644
--- a/src/file-input/styles.scss
+++ b/src/file-input/styles.scss
@@ -6,13 +6,25 @@
 @use '../internal/styles' as styles;
 @use '@cloudscape-design/component-toolkit/internal/focus-visible' as focus-visible;
 
-.root,
-.file-input {
-  /* used in test-utils */
+.root {
+  position: relative;
 }
 
-.hidden {
-  @include styles.awsui-util-hide;
+.file-input {
+  // Adapted from https://webaim.org/techniques/css/invisiblecontent/
+
+  position: absolute;
+  inset-block-start: 0;
+  inset-inline-start: 0;
+  clip: rect(1px, 1px, 1px, 1px);
+  clip-path: inset(50%);
+  block-size: 1px;
+  inline-size: 1px;
+  margin-block: -1px;
+  margin-inline: -1px;
+  padding-block: 0;
+  padding-inline: 0;
+  overflow: hidden;
 }
 
 .file-input-button {

From 7a4c143fd40add457dba7d375a5817eb6927f3f2 Mon Sep 17 00:00:00 2001
From: Andrei Zhaleznichenka <zhalea@amazon.de>
Date: Thu, 11 Sep 2025 09:46:04 +0200
Subject: [PATCH 13/32] chore: Fixes virtual dropdown tests for React 18
 (#3842)

---
 src/__integ__/page-objects/async-dropdown-page.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/__integ__/page-objects/async-dropdown-page.ts b/src/__integ__/page-objects/async-dropdown-page.ts
index 5c033209bb..7692089c7f 100644
--- a/src/__integ__/page-objects/async-dropdown-page.ts
+++ b/src/__integ__/page-objects/async-dropdown-page.ts
@@ -69,6 +69,7 @@ class AsyncDropdownPage extends BasePageObject {
       items,
       hasNextPage
     );
+    await this.waitForJsTimers(10);
   }
 
   async reject() {

From 183fb94425924d9ef68a7b936fc812f71cedb706 Mon Sep 17 00:00:00 2001
From: Trevor Burnham <trevorburnham@gmail.com>
Date: Thu, 11 Sep 2025 07:40:54 -0400
Subject: [PATCH 14/32] chore: Remove ResizeObserver polyfill (#3790)

Co-authored-by: Boris Serdiuk <serdiuk@amazon.com>
---
 __mocks__/@juggle/resize-observer.ts          | 31 +++++++++++++++++--
 build-tools/jest/setup.js                     | 10 ++++++
 package-lock.json                             |  1 -
 package.json                                  |  1 -
 .../sticky-scrollbar/use-sticky-scrollbar.ts  |  3 +-
 5 files changed, 40 insertions(+), 6 deletions(-)

diff --git a/__mocks__/@juggle/resize-observer.ts b/__mocks__/@juggle/resize-observer.ts
index 620bfd6992..50199d144b 100644
--- a/__mocks__/@juggle/resize-observer.ts
+++ b/__mocks__/@juggle/resize-observer.ts
@@ -2,7 +2,6 @@
 /* eslint-disable header/header */
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { ResizeObserver, ResizeObserverEntry } from '@juggle/resize-observer';
 
 const callbackField = Symbol();
 
@@ -37,5 +36,33 @@ class MockResizeObserver implements ResizeObserver {
   }
 }
 
-export { ResizeObserverEntry };
+class MockResizeObserverEntry implements ResizeObserverEntry {
+  readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;
+  readonly contentBoxSize: ReadonlyArray<ResizeObserverSize>;
+  readonly devicePixelContentBoxSize: ReadonlyArray<ResizeObserverSize>;
+  readonly contentRect: DOMRectReadOnly;
+  readonly target: Element;
+
+  constructor(target: Element) {
+    this.target = target;
+    const size = { inlineSize: 0, blockSize: 0 };
+    this.borderBoxSize = [size];
+    this.contentBoxSize = [size];
+    this.devicePixelContentBoxSize = [size];
+    // Create a simple DOMRectReadOnly mock for JSDOM compatibility
+    this.contentRect = {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0,
+      toJSON: () => ({}),
+    } as DOMRectReadOnly;
+  }
+}
+
 export { MockResizeObserver as ResizeObserver };
+export { MockResizeObserverEntry as ResizeObserverEntry };
diff --git a/build-tools/jest/setup.js b/build-tools/jest/setup.js
index 19a1ca30b5..0056854f65 100644
--- a/build-tools/jest/setup.js
+++ b/build-tools/jest/setup.js
@@ -7,4 +7,14 @@ if (typeof window !== 'undefined') {
   require('@testing-library/jest-dom/extend-expect');
   const { cleanup } = require('@testing-library/react');
   afterEach(cleanup);
+
+  // Mock ResizeObserver for JSDOM environment
+  global.ResizeObserver = class ResizeObserver {
+    constructor(callback) {
+      this.callback = callback;
+    }
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  };
 }
diff --git a/package-lock.json b/package-lock.json
index 9c7bf020b9..f757bd382a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -15,7 +15,6 @@
         "@dnd-kit/core": "^6.0.8",
         "@dnd-kit/sortable": "^7.0.2",
         "@dnd-kit/utilities": "^3.2.1",
-        "@juggle/resize-observer": "^3.3.1",
         "ace-builds": "^1.34.0",
         "balanced-match": "^1.0.2",
         "clsx": "^1.1.0",
diff --git a/package.json b/package.json
index cbff2ebddf..5b18fa5302 100644
--- a/package.json
+++ b/package.json
@@ -32,7 +32,6 @@
     "@dnd-kit/core": "^6.0.8",
     "@dnd-kit/sortable": "^7.0.2",
     "@dnd-kit/utilities": "^3.2.1",
-    "@juggle/resize-observer": "^3.3.1",
     "ace-builds": "^1.34.0",
     "balanced-match": "^1.0.2",
     "clsx": "^1.1.0",
diff --git a/src/table/sticky-scrollbar/use-sticky-scrollbar.ts b/src/table/sticky-scrollbar/use-sticky-scrollbar.ts
index b61e8164d9..b2d819aa4a 100644
--- a/src/table/sticky-scrollbar/use-sticky-scrollbar.ts
+++ b/src/table/sticky-scrollbar/use-sticky-scrollbar.ts
@@ -1,7 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { RefObject, useEffect, useState } from 'react';
-import { ResizeObserver } from '@juggle/resize-observer';
 
 import { getLogicalBoundingClientRect } from '@cloudscape-design/component-toolkit/internal';
 
@@ -85,7 +84,7 @@ export function useStickyScrollbar(
 
   // Update scrollbar position wrapper or table size change.
   useEffect(() => {
-    if (wrapperRef.current && tableRef.current) {
+    if (wrapperRef.current && tableRef.current && typeof ResizeObserver !== 'undefined') {
       const observer = new ResizeObserver(() => {
         if (scrollbarContentRef.current) {
           updatePosition(

From a6ea58d376ae6c6aaa4ef28dba59a6a3439c066d Mon Sep 17 00:00:00 2001
From: Boris Serdiuk <serdiuk@amazon.com>
Date: Thu, 11 Sep 2025 15:48:10 +0200
Subject: [PATCH 15/32] chore: Update test-utils doc snapshots (#3853)

---
 .../__snapshots__/documenter.test.ts.snap     | 11008 ++++++++++------
 1 file changed, 7298 insertions(+), 3710 deletions(-)

diff --git a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
index ffe824f8a5..36f3f9d024 100644
--- a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
+++ b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
@@ -88499,22 +88499,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findAddButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
-        {
-          "name": "findAdditionalInfo",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -88667,7 +88651,10 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findEmptySlot",
+          "inheritedFrom": {
+            "name": "ChartPopoverSeriesItemWrapper.findKey",
+          },
+          "name": "findKey",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -88675,39 +88662,29 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns a row for a given index.",
-          "name": "findRow",
-          "parameters": [
-            {
-              "description": "1-based row index",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "row",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "AttributeEditorRowWrapper",
-          },
-        },
-        {
-          "description": "Returns all rows.
-
-To find a specific row use the \`findRow(n)\` function as chaining \`findRows().get(n)\` can return unexpected results.",
-          "name": "findRows",
+          "name": "findSubItems",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "MultiElementWrapper",
             "typeArguments": [
               {
-                "name": "AttributeEditorRowWrapper",
+                "name": "ChartPopoverSeriesItemWrapper",
               },
             ],
           },
         },
+        {
+          "inheritedFrom": {
+            "name": "ChartPopoverSeriesItemWrapper.findValue",
+          },
+          "name": "findValue",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -88750,7 +88727,7 @@ To find a specific row use the \`findRow(n)\` function as chaining \`findRows().
           },
         },
       ],
-      "name": "AttributeEditorWrapper",
+      "name": "ChartPopoverSeriesWrapper",
     },
     {
       "methods": [
@@ -88925,7 +88902,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findCustomAction",
+          "name": "findKey",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -88933,43 +88910,11 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns a field for a given index",
-          "name": "findField",
-          "parameters": [
-            {
-              "description": "1-based column index",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "column",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "FormFieldWrapper",
-          },
-        },
-        {
-          "description": "Returns all fields. Fields are supplied in the \`definition\` property of the component.",
-          "name": "findFields",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "FormFieldWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "name": "findRemoveButton",
+          "name": "findValue",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
@@ -89014,7 +88959,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "AttributeEditorRowWrapper",
+      "name": "ChartPopoverSeriesItemWrapper",
     },
     {
       "methods": [
@@ -89037,6 +88982,22 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findAddButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "name": "findAdditionalInfo",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -89189,47 +89150,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findConstraint",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findControl",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findDescription",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findError",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findInfo",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findLabel",
+          "name": "findEmptySlot",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -89237,19 +89158,37 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findSecondaryControl",
-          "parameters": [],
+          "description": "Returns a row for a given index.",
+          "name": "findRow",
+          "parameters": [
+            {
+              "description": "1-based row index",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "row",
+              "typeName": "number",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "AttributeEditorRowWrapper",
           },
         },
         {
-          "name": "findWarning",
+          "description": "Returns all rows.
+
+To find a specific row use the \`findRow(n)\` function as chaining \`findRows().get(n)\` can return unexpected results.",
+          "name": "findRows",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "AttributeEditorRowWrapper",
+              },
+            ],
           },
         },
         {
@@ -89294,7 +89233,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "FormFieldWrapper",
+      "name": "AttributeEditorWrapper",
     },
     {
       "methods": [
@@ -89437,17 +89376,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "inheritedFrom": {
-            "name": "InputWrapper.findClearButton",
-          },
-          "name": "findClearButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -89480,94 +89408,51 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findDropdown",
-          "parameters": [
-            {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
-            },
-          ],
+          "name": "findCustomAction",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "AutosuggestDropdownWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findEnteredTextOption",
+          "description": "Returns a field for a given index",
+          "name": "findField",
           "parameters": [
             {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "description": "1-based column index",
               "flags": {
                 "isOptional": false,
               },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
+              "name": "column",
+              "typeName": "number",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "FormFieldWrapper",
           },
         },
         {
-          "name": "findErrorRecoveryButton",
-          "parameters": [
-            {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
-            },
-          ],
+          "description": "Returns all fields. Fields are supplied in the \`definition\` property of the component.",
+          "name": "findFields",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "FormFieldWrapper",
+              },
+            ],
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseInputWrapper.findNativeInput",
-          },
-          "name": "findNativeInput",
+          "name": "findRemoveButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findStatusIndicator",
-          "parameters": [
-            {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
@@ -89612,7 +89497,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "AutosuggestWrapper",
+      "name": "AttributeEditorRowWrapper",
     },
     {
       "methods": [
@@ -89787,21 +89672,15 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns all the selected options.",
-          "name": "findDisabledOptions",
+          "name": "findConstraint",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "OptionWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findFooterRegion",
+          "name": "findControl",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -89809,7 +89688,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findHighlightedAriaLiveRegion",
+          "name": "findDescription",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -89817,30 +89696,23 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns highlighted text fragments from all of the options.
-Options get highlighted when they match the value of the input field.",
-          "name": "findHighlightedMatches",
+          "name": "findError",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findHighlightedOption",
+          "name": "findInfo",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "OptionWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findOpenDropdown",
+          "name": "findLabel",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -89848,83 +89720,15 @@ Options get highlighted when they match the value of the input field.",
           },
         },
         {
-          "description": "Returns an option from the dropdown.",
-          "name": "findOption",
-          "parameters": [
-            {
-              "description": "1-based index of the option to select.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "optionIndex",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "OptionWrapper",
-          },
-        },
-        {
-          "description": "Returns an option from the autosuggest by it's value",
-          "name": "findOptionByValue",
-          "parameters": [
-            {
-              "description": "The 'value' of the option.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "value",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "OptionWrapper",
-          },
-        },
-        {
-          "description": "Returns an option from the dropdown.",
-          "name": "findOptionInGroup",
-          "parameters": [
-            {
-              "description": "1-based index of the group to select an option in.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "groupIndex",
-              "typeName": "number",
-            },
-            {
-              "description": "1-based index of the option to select.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "optionIndex",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "OptionWrapper",
-          },
-        },
-        {
-          "name": "findOptions",
+          "name": "findSecondaryControl",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "OptionWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
-          "description": "Use this element to scroll through the list of options",
-          "name": "findOptionsContainer",
+          "name": "findWarning",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -89973,7 +89777,7 @@ Options get highlighted when they match the value of the input field.",
           },
         },
       ],
-      "name": "AutosuggestDropdownWrapper",
+      "name": "FormFieldWrapper",
     },
     {
       "methods": [
@@ -90116,6 +89920,17 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "inheritedFrom": {
+            "name": "InputWrapper.findClearButton",
+          },
+          "name": "findClearButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -90147,6 +89962,97 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
+        {
+          "name": "findDropdown",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "AutosuggestDropdownWrapper",
+          },
+        },
+        {
+          "name": "findEnteredTextOption",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findErrorRecoveryButton",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "BaseInputWrapper.findNativeInput",
+          },
+          "name": "findNativeInput",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findStatusIndicator",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -90189,7 +90095,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "BadgeWrapper",
+      "name": "AutosuggestWrapper",
     },
     {
       "methods": [
@@ -90314,59 +90220,19 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "description": "Returns a focusable element that controls keyboard interactions.",
           "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findApplication",
+            "name": "AbstractWrapper.findByClassName",
           },
-          "name": "findApplication",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Returns an array of bar groups, which are used for mouse navigation if a chart contains bar series.",
-          "inheritedFrom": {
-            "name": "MixedLineBarChartWrapper.findBarGroups",
-          },
-          "name": "findBarGroups",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.findByClassName",
-          },
-          "name": "findByClassName",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "className",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findChart",
-          },
-          "name": "findChart",
-          "parameters": [],
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
@@ -90404,32 +90270,21 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "CommonChartWrapper.findDefaultFilter",
-          },
-          "name": "findDefaultFilter",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ChartFilterWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "CommonChartWrapper.findDetailPopover",
-          },
-          "name": "findDetailPopover",
+          "description": "Returns all the selected options.",
+          "name": "findDisabledOptions",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ChartPopoverWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "OptionWrapper",
+              },
+            ],
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findFilterContainer",
-          },
-          "name": "findFilterContainer",
+          "name": "findFooterRegion",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -90437,10 +90292,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findHighlightedSeries",
-          },
-          "name": "findHighlightedSeries",
+          "name": "findHighlightedAriaLiveRegion",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -90448,22 +90300,9 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "CommonChartWrapper.findLegend",
-          },
-          "name": "findLegend",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ChartLegendWrapper",
-          },
-        },
-        {
-          "description": "Returns an array of chart series. Note that thresholds count as series as well.",
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findSeries",
-          },
-          "name": "findSeries",
+          "description": "Returns highlighted text fragments from all of the options.
+Options get highlighted when they match the value of the input field.",
+          "name": "findHighlightedMatches",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -90476,21 +90315,15 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "CommonChartWrapper.findStatusContainer",
-          },
-          "name": "findStatusContainer",
+          "name": "findHighlightedOption",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "OptionWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findXAxisTitle",
-          },
-          "name": "findXAxisTitle",
+          "name": "findOpenDropdown",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -90498,48 +90331,89 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findXTicks",
-          },
-          "name": "findXTicks",
-          "parameters": [],
+          "description": "Returns an option from the dropdown.",
+          "name": "findOption",
+          "parameters": [
+            {
+              "description": "1-based index of the option to select.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "optionIndex",
+              "typeName": "number",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
+            "name": "OptionWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findYAxisTitle",
-          },
-          "name": "findYAxisTitle",
-          "parameters": [],
+          "description": "Returns an option from the autosuggest by it's value",
+          "name": "findOptionByValue",
+          "parameters": [
+            {
+              "description": "The 'value' of the option.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "value",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "OptionWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findYTicks",
+          "description": "Returns an option from the dropdown.",
+          "name": "findOptionInGroup",
+          "parameters": [
+            {
+              "description": "1-based index of the group to select an option in.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "groupIndex",
+              "typeName": "number",
+            },
+            {
+              "description": "1-based index of the option to select.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "optionIndex",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "OptionWrapper",
           },
-          "name": "findYTicks",
+        },
+        {
+          "name": "findOptions",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "MultiElementWrapper",
             "typeArguments": [
               {
-                "name": "ElementWrapper",
+                "name": "OptionWrapper",
               },
             ],
           },
         },
+        {
+          "description": "Use this element to scroll through the list of options",
+          "name": "findOptionsContainer",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -90582,7 +90456,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "BarChartWrapper",
+      "name": "AutosuggestDropdownWrapper",
     },
     {
       "methods": [
@@ -90798,7 +90672,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "BoxWrapper",
+      "name": "BadgeWrapper",
     },
     {
       "methods": [
@@ -90923,30 +90797,23 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "description": "Returns an item for a given index. Note that this may return the 'current' page item for backwards compatibility,
-even though it is not technically a link.",
-          "name": "findBreadcrumbLink",
-          "parameters": [
-            {
-              "description": "1-based item index",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "index",
-              "typeName": "number",
-            },
-          ],
+          "description": "Returns a focusable element that controls keyboard interactions.",
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findApplication",
+          },
+          "name": "findApplication",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
         {
-          "description": "Returns all breadcrumb items. Note that this includes the 'current' page item for backwards compatibility,
-even though it is not technically a link.
-
-To find a specific item use the \`findBreadcrumbLink(n)\` function as chaining \`findBreadcrumbLinks().get(n)\` can return unexpected results.",
-          "name": "findBreadcrumbLinks",
+          "description": "Returns an array of bar groups, which are used for mouse navigation if a chart contains bar series.",
+          "inheritedFrom": {
+            "name": "MixedLineBarChartWrapper.findBarGroups",
+          },
+          "name": "findBarGroups",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -90977,6 +90844,17 @@ To find a specific item use the \`findBreadcrumbLink(n)\` function as chaining \
             "name": "ElementWrapper",
           },
         },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findChart",
+          },
+          "name": "findChart",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -91009,33 +90887,162 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findDropdown",
+          "inheritedFrom": {
+            "name": "CommonChartWrapper.findDefaultFilter",
+          },
+          "name": "findDefaultFilter",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonDropdownWrapper",
+            "name": "ChartFilterWrapper",
           },
         },
         {
           "inheritedFrom": {
-            "name": "AbstractWrapper.getElement",
+            "name": "CommonChartWrapper.findDetailPopover",
           },
-          "name": "getElement",
+          "name": "findDetailPopover",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "string",
+            "name": "ChartPopoverWrapper",
           },
         },
         {
           "inheritedFrom": {
-            "name": "AbstractWrapper.matches",
+            "name": "BaseCartesianChartWrapper.findFilterContainer",
           },
-          "name": "matches",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
+          "name": "findFilterContainer",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findHighlightedSeries",
+          },
+          "name": "findHighlightedSeries",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "CommonChartWrapper.findLegend",
+          },
+          "name": "findLegend",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ChartLegendWrapper",
+          },
+        },
+        {
+          "description": "Returns an array of chart series. Note that thresholds count as series as well.",
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findSeries",
+          },
+          "name": "findSeries",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "CommonChartWrapper.findStatusContainer",
+          },
+          "name": "findStatusContainer",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findXAxisTitle",
+          },
+          "name": "findXAxisTitle",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findXTicks",
+          },
+          "name": "findXTicks",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findYAxisTitle",
+          },
+          "name": "findYAxisTitle",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findYTicks",
+          },
+          "name": "findYTicks",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
               },
               "name": "selector",
               "typeName": "string",
@@ -91058,7 +91065,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "BreadcrumbGroupWrapper",
+      "name": "BarChartWrapper",
     },
     {
       "methods": [
@@ -91182,23 +91189,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "description": "Finds a button item by its id.",
-          "name": "findButtonById",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "id",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -91249,80 +91239,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
-        {
-          "description": "Finds a file input item by its id.",
-          "name": "findFileInputById",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "id",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "FileInputWrapper",
-          },
-        },
-        {
-          "description": "Finds all button and menu items.",
-          "name": "findItems",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "description": "Finds a menu item by its id.",
-          "name": "findMenuById",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "id",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonDropdownWrapper",
-          },
-        },
-        {
-          "description": "Finds a toggle button item by its id.",
-          "name": "findToggleButtonById",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "id",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ToggleButtonWrapper",
-          },
-        },
-        {
-          "description": "Finds the currently opened tooltip.",
-          "name": "findTooltip",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -91365,7 +91281,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ButtonGroupWrapper",
+      "name": "BoxWrapper",
     },
     {
       "methods": [
@@ -91490,17 +91406,17 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.findByClassName",
-          },
-          "name": "findByClassName",
+          "description": "Returns an item for a given index. Note that this may return the 'current' page item for backwards compatibility,
+even though it is not technically a link.",
+          "name": "findBreadcrumbLink",
           "parameters": [
             {
+              "description": "1-based item index",
               "flags": {
                 "isOptional": false,
               },
-              "name": "className",
-              "typeName": "string",
+              "name": "index",
+              "typeName": "number",
             },
           ],
           "returnType": {
@@ -91509,13 +91425,49 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+          "description": "Returns all breadcrumb items. Note that this includes the 'current' page item for backwards compatibility,
+even though it is not technically a link.
 
-Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
-          "inheritedFrom": {
-            "name": "AbstractWrapper.findComponent",
+To find a specific item use the \`findBreadcrumbLink(n)\` function as chaining \`findBreadcrumbLinks().get(n)\` can return unexpected results.",
+          "name": "findBreadcrumbLinks",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
-          "name": "findComponent",
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
           "parameters": [
             {
               "description": "CSS selector",
@@ -91540,36 +91492,11 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "ButtonWrapper.findDisabledReason",
-          },
-          "name": "findDisabledReason",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "ButtonWrapper.findLoadingIndicator",
-          },
-          "name": "findLoadingIndicator",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "ButtonWrapper.findTextRegion",
-          },
-          "name": "findTextRegion",
+          "name": "findDropdown",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ButtonDropdownWrapper",
           },
         },
         {
@@ -91614,7 +91541,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ToggleButtonWrapper",
+      "name": "BreadcrumbGroupWrapper",
     },
     {
       "methods": [
@@ -91738,6 +91665,23 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "description": "Finds a button item by its id.",
+          "name": "findButtonById",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -91789,19 +91733,77 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findNativeInput",
+          "description": "Finds a file input item by its id.",
+          "name": "findFileInputById",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "FileInputWrapper",
+          },
+        },
+        {
+          "description": "Finds all button and menu items.",
+          "name": "findItems",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findTrigger",
+          "description": "Finds a menu item by its id.",
+          "name": "findMenuById",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonDropdownWrapper",
+          },
+        },
+        {
+          "description": "Finds a toggle button item by its id.",
+          "name": "findToggleButtonById",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ToggleButtonWrapper",
+          },
+        },
+        {
+          "description": "Finds the currently opened tooltip.",
+          "name": "findTooltip",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
@@ -91846,7 +91848,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "FileInputWrapper",
+      "name": "ButtonGroupWrapper",
     },
     {
       "methods": [
@@ -92021,33 +92023,10 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns a date container on the calendar.",
-          "name": "findDateAt",
-          "parameters": [
-            {
-              "description": "1-based row index of the day or month.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "row",
-              "typeName": "number",
-            },
-            {
-              "description": "1-based column index of the day or month.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "column",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "CalendarDateWrapper",
+          "inheritedFrom": {
+            "name": "ButtonWrapper.findDisabledReason",
           },
-        },
-        {
-          "name": "findHeader",
+          "name": "findDisabledReason",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -92055,41 +92034,21 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findNextButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
-        {
-          "description": "Alias for findNextButton for compatibility with previous versions",
-          "name": "findNextMonthButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
+          "inheritedFrom": {
+            "name": "ButtonWrapper.findLoadingIndicator",
           },
-        },
-        {
-          "name": "findPreviousButton",
+          "name": "findLoadingIndicator",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "description": "Alias for findPreviousButton for compatibility with previous versions",
-          "name": "findPreviousMonthButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
+          "inheritedFrom": {
+            "name": "ButtonWrapper.findTextRegion",
           },
-        },
-        {
-          "name": "findSelectedDate",
+          "name": "findTextRegion",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -92138,7 +92097,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "CalendarWrapper",
+      "name": "ToggleButtonWrapper",
     },
     {
       "methods": [
@@ -92313,13 +92272,21 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findDisabledReason",
+          "name": "findNativeInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findTrigger",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -92362,7 +92329,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "CalendarDateWrapper",
+      "name": "FileInputWrapper",
     },
     {
       "methods": [
@@ -92505,14 +92472,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findCollectionPreferences",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "CollectionPreferencesWrapper",
-          },
-        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -92545,16 +92504,33 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Alias for findEmptySlot method for compatibility with previous versions",
-          "name": "findEmptyRegion",
-          "parameters": [],
+          "description": "Returns a date container on the calendar.",
+          "name": "findDateAt",
+          "parameters": [
+            {
+              "description": "1-based row index of the day or month.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "row",
+              "typeName": "number",
+            },
+            {
+              "description": "1-based column index of the day or month.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "column",
+              "typeName": "number",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "CalendarDateWrapper",
           },
         },
         {
-          "name": "findEmptySlot",
+          "name": "findHeader",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -92562,70 +92538,45 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findHeader",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Alias for findHeader method for compatibility with previous versions",
-          "name": "findHeaderRegion",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findItems",
+          "name": "findNextButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "CardWrapper",
-              },
-            ],
+            "name": "ButtonWrapper",
           },
         },
         {
-          "name": "findLoadingText",
+          "description": "Alias for findNextButton for compatibility with previous versions",
+          "name": "findNextMonthButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
-          "name": "findPagination",
+          "name": "findPreviousButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "PaginationWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
-          "name": "findSelectedItems",
+          "description": "Alias for findPreviousButton for compatibility with previous versions",
+          "name": "findPreviousMonthButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "CardWrapper",
-              },
-            ],
+            "name": "ButtonWrapper",
           },
         },
         {
-          "name": "findTextFilter",
+          "name": "findSelectedDate",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "TextFilterWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
@@ -92670,7 +92621,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "CardsWrapper",
+      "name": "CalendarWrapper",
     },
     {
       "methods": [
@@ -92845,15 +92796,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findInput",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "InputWrapper",
-          },
-        },
-        {
-          "name": "findResultsCount",
+          "name": "findDisabledReason",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -92902,7 +92845,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TextFilterWrapper",
+      "name": "CalendarDateWrapper",
     },
     {
       "methods": [
@@ -93046,11 +92989,11 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "name": "findClearButton",
+          "name": "findCollectionPreferences",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "CollectionPreferencesWrapper",
           },
         },
         {
@@ -93085,16 +93028,89 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseInputWrapper.findNativeInput",
+          "description": "Alias for findEmptySlot method for compatibility with previous versions",
+          "name": "findEmptyRegion",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
           },
-          "name": "findNativeInput",
+        },
+        {
+          "name": "findEmptySlot",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findHeader",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Alias for findHeader method for compatibility with previous versions",
+          "name": "findHeaderRegion",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findItems",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "CardWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "name": "findLoadingText",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findPagination",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "PaginationWrapper",
+          },
+        },
+        {
+          "name": "findSelectedItems",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "CardWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "name": "findTextFilter",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "TextFilterWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -93137,7 +93153,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "InputWrapper",
+      "name": "CardsWrapper",
     },
     {
       "methods": [
@@ -93280,6 +93296,14 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findCardHeader",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -93312,54 +93336,23 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findCurrentPage",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findNextPageButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Returns a page number for a given index.",
-          "name": "findPageNumberByIndex",
-          "parameters": [
-            {
-              "description": "1-based index of the page number to return.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "index",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findPageNumbers",
+          "description": "Note: for integration/selector-based tests you should add \`1\` to the expected section index,
+for example, \`.findSections().get(sectionIndex+1)\`. The \`get\` call in this context
+is '2-indexed', that is, the first section in a card has an index of \`2\`.",
+          "name": "findSections",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "MultiElementWrapper",
             "typeArguments": [
               {
-                "name": "ElementWrapper",
+                "name": "CardSectionWrapper",
               },
             ],
           },
         },
         {
-          "name": "findPreviousPageButton",
+          "name": "findSelectionArea",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -93408,7 +93401,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "PaginationWrapper",
+      "name": "CardWrapper",
     },
     {
       "methods": [
@@ -93583,19 +93576,19 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findModal",
+          "name": "findContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "PreferencesModalWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findTriggerButton",
+          "name": "findSectionHeader",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
@@ -93640,7 +93633,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "CollectionPreferencesWrapper",
+      "name": "CardSectionWrapper",
     },
     {
       "methods": [
@@ -93783,14 +93776,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findCancelButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -93823,18 +93808,15 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findConfirmButton",
+          "name": "findInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "InputWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "ModalWrapper.findContent",
-          },
-          "name": "findContent",
+          "name": "findResultsCount",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -93842,147 +93824,33 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findContentBefore",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "string",
           },
         },
         {
-          "name": "findContentDensityPreference",
-          "parameters": [],
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "CheckboxWrapper",
-          },
-        },
-        {
-          "name": "findContentDisplayPreference",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ContentDisplayPreferenceWrapper",
-          },
-        },
-        {
-          "name": "findCustomPreference",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "ModalWrapper.findDismissButton",
-          },
-          "name": "findDismissButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "ModalWrapper.findFooter",
-          },
-          "name": "findFooter",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "ModalWrapper.findHeader",
-          },
-          "name": "findHeader",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findPageSizePreference",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "PageSizePreferenceWrapper",
-          },
-        },
-        {
-          "name": "findStickyColumnsPreference",
-          "parameters": [
-            {
-              "defaultValue": "'first'",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "firstOrLast",
-              "typeName": ""first" | "last"",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "StickyColumnsPreferenceWrapper",
-          },
-        },
-        {
-          "name": "findStripedRowsPreference",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "CheckboxWrapper",
-          },
-        },
-        {
-          "name": "findVisibleContentPreference",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "VisibleContentPreferenceWrapper",
-          },
-        },
-        {
-          "name": "findWrapLinesPreference",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "CheckboxWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.getElement",
-          },
-          "name": "getElement",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "string",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.matches",
-          },
-          "name": "matches",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "selector",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
@@ -93997,7 +93865,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "PreferencesModalWrapper",
+      "name": "TextFilterWrapper",
     },
     {
       "methods": [
@@ -94140,6 +94008,14 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findClearButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -94172,22 +94048,9 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findDescription",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findLabel",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
+          "inheritedFrom": {
+            "name": "BaseInputWrapper.findNativeInput",
           },
-        },
-        {
           "name": "findNativeInput",
           "parameters": [],
           "returnType": {
@@ -94237,7 +94100,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "CheckboxWrapper",
+      "name": "InputWrapper",
     },
     {
       "methods": [
@@ -94412,20 +94275,54 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findOptions",
+          "name": "findCurrentPage",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findNextPageButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a page number for a given index.",
+          "name": "findPageNumberByIndex",
+          "parameters": [
+            {
+              "description": "1-based index of the page number to return.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findPageNumbers",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "MultiElementWrapper",
             "typeArguments": [
               {
-                "name": "RadioButtonWrapper",
+                "name": "ElementWrapper",
               },
             ],
           },
         },
         {
-          "name": "findTitle",
+          "name": "findPreviousPageButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -94474,7 +94371,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "PageSizePreferenceWrapper",
+      "name": "PaginationWrapper",
     },
     {
       "methods": [
@@ -94649,63 +94546,19 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findOptions",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "name": "findOptionsGroups",
+          "name": "findModal",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
+            "name": "PreferencesModalWrapper",
           },
         },
         {
-          "name": "findTitle",
+          "name": "findTriggerButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Returns a content selector toggle.",
-          "name": "findToggleByIndex",
-          "parameters": [
-            {
-              "description": "1-based index of the content group.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "groupIndex",
-              "typeName": "number",
-            },
-            {
-              "description": "1-based index of the option to return within the group.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "optionIndex",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ToggleWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
@@ -94750,7 +94603,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "VisibleContentPreferenceWrapper",
+      "name": "CollectionPreferencesWrapper",
     },
     {
       "methods": [
@@ -94894,13 +94747,21 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
-
-Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
-          "inheritedFrom": {
-            "name": "AbstractWrapper.findComponent",
-          },
-          "name": "findComponent",
+          "name": "findCancelButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
           "parameters": [
             {
               "description": "CSS selector",
@@ -94925,7 +94786,18 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findDescription",
+          "name": "findConfirmButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "ModalWrapper.findContent",
+          },
+          "name": "findContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -94933,7 +94805,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findLabel",
+          "name": "findContentBefore",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -94941,13 +94813,111 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findNativeInput",
+          "name": "findContentDensityPreference",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "CheckboxWrapper",
+          },
+        },
+        {
+          "name": "findContentDisplayPreference",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ContentDisplayPreferenceWrapper",
+          },
+        },
+        {
+          "name": "findCustomPreference",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "ModalWrapper.findDismissButton",
+          },
+          "name": "findDismissButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "ModalWrapper.findFooter",
+          },
+          "name": "findFooter",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "ModalWrapper.findHeader",
+          },
+          "name": "findHeader",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findPageSizePreference",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "PageSizePreferenceWrapper",
+          },
+        },
+        {
+          "name": "findStickyColumnsPreference",
+          "parameters": [
+            {
+              "defaultValue": "'first'",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "firstOrLast",
+              "typeName": ""first" | "last"",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "StickyColumnsPreferenceWrapper",
+          },
+        },
+        {
+          "name": "findStripedRowsPreference",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "CheckboxWrapper",
+          },
+        },
+        {
+          "name": "findVisibleContentPreference",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "VisibleContentPreferenceWrapper",
+          },
+        },
+        {
+          "name": "findWrapLinesPreference",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "CheckboxWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -94990,7 +94960,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ToggleWrapper",
+      "name": "PreferencesModalWrapper",
     },
     {
       "methods": [
@@ -95173,15 +95143,15 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findRadioGroup",
+          "name": "findLabel",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "RadioGroupWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findTitle",
+          "name": "findNativeInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -95230,7 +95200,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "StickyColumnsPreferenceWrapper",
+      "name": "CheckboxWrapper",
     },
     {
       "methods": [
@@ -95354,19 +95324,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findButtons",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "RadioButtonWrapper",
-              },
-            ],
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -95418,16 +95375,21 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findInputByValue",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
+          "name": "findOptions",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "RadioButtonWrapper",
               },
-              "name": "value",
-              "typeName": "string",
-            },
-          ],
+            ],
+          },
+        },
+        {
+          "name": "findTitle",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
@@ -95475,7 +95437,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "RadioGroupWrapper",
+      "name": "PageSizePreferenceWrapper",
     },
     {
       "methods": [
@@ -95650,7 +95612,6 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns the preference description displayed below the title.",
           "name": "findDescription",
           "parameters": [],
           "returnType": {
@@ -95659,8 +95620,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns no match with the clear filter button.",
-          "name": "findNoMatch",
+          "name": "findLabel",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -95668,49 +95628,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns an option for a given index.",
-          "name": "findOptionByIndex",
-          "parameters": [
-            {
-              "description": "1-based index of the option to return.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "index",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ContentDisplayOptionWrapper",
-          },
-        },
-        {
-          "description": "Returns options that the user can reorder.",
-          "name": "findOptions",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ContentDisplayOptionWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "description": "Returns the text filter input.",
-          "name": "findTextFilter",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "TextFilterWrapper",
-          },
-        },
-        {
-          "description": "Returns the title.",
-          "name": "findTitle",
+          "name": "findNativeInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -95759,7 +95677,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ContentDisplayPreferenceWrapper",
+      "name": "RadioButtonWrapper",
     },
     {
       "methods": [
@@ -95934,36 +95852,69 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns the drag handle for the option item.",
-          "name": "findDragHandle",
+          "name": "findOptions",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
         {
-          "description": "Returns the text label displayed in the option item.",
-          "name": "findLabel",
+          "name": "findOptionsGroups",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
         {
-          "description": "Returns the visibility toggle for the option item.",
-          "name": "findVisibilityToggle",
+          "name": "findTitle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ToggleWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.getElement",
-          },
+          "description": "Returns a content selector toggle.",
+          "name": "findToggleByIndex",
+          "parameters": [
+            {
+              "description": "1-based index of the content group.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "groupIndex",
+              "typeName": "number",
+            },
+            {
+              "description": "1-based index of the option to return within the group.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "optionIndex",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ToggleWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
           "name": "getElement",
           "parameters": [],
           "returnType": {
@@ -96002,7 +95953,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ContentDisplayOptionWrapper",
+      "name": "VisibleContentPreferenceWrapper",
     },
     {
       "methods": [
@@ -96177,47 +96128,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findEditor",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findErrorScreen",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findErrorsTab",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findLoadingScreen",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findNativeTextArea",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findPane",
+          "name": "findDescription",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -96225,15 +96136,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findSettingsButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
-        {
-          "name": "findStatusBar",
+          "name": "findLabel",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -96241,7 +96144,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findWarningsTab",
+          "name": "findNativeInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -96290,7 +96193,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "CodeEditorWrapper",
+      "name": "ToggleWrapper",
     },
     {
       "methods": [
@@ -96433,27 +96336,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "description": "Returns a column from the grid for a given index.",
-          "inheritedFrom": {
-            "name": "GridWrapper.findColumn",
-          },
-          "name": "findColumn",
-          "parameters": [
-            {
-              "description": "1-based index of the column to return.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "columnIndex",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -96485,6 +96367,30 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
+        {
+          "name": "findDescription",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findRadioGroup",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "RadioGroupWrapper",
+          },
+        },
+        {
+          "name": "findTitle",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -96527,7 +96433,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ColumnLayoutWrapper",
+      "name": "StickyColumnsPreferenceWrapper",
     },
     {
       "methods": [
@@ -96651,6 +96557,19 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findButtons",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "RadioButtonWrapper",
+              },
+            ],
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -96702,32 +96621,16 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findContent",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findFooter",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findHeader",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findMedia",
-          "parameters": [],
+          "name": "findInputByValue",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "value",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
@@ -96775,7 +96678,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ContainerWrapper",
+      "name": "RadioGroupWrapper",
     },
     {
       "methods": [
@@ -96899,14 +96802,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findBreadcrumbs",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -96958,7 +96853,8 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findContent",
+          "description": "Returns the preference description displayed below the title.",
+          "name": "findDescription",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -96966,7 +96862,8 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findHeader",
+          "description": "Returns no match with the clear filter button.",
+          "name": "findNoMatch",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -96974,15 +96871,49 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findNotifications",
+          "description": "Returns an option for a given index.",
+          "name": "findOptionByIndex",
+          "parameters": [
+            {
+              "description": "1-based index of the option to return.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ContentDisplayOptionWrapper",
+          },
+        },
+        {
+          "description": "Returns options that the user can reorder.",
+          "name": "findOptions",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ContentDisplayOptionWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findSecondaryHeader",
+          "description": "Returns the text filter input.",
+          "name": "findTextFilter",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "TextFilterWrapper",
+          },
+        },
+        {
+          "description": "Returns the title.",
+          "name": "findTitle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -97031,7 +96962,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ContentLayoutWrapper",
+      "name": "ContentDisplayPreferenceWrapper",
     },
     {
       "methods": [
@@ -97206,17 +97137,17 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findCopyButton",
+          "description": "Returns the drag handle for the option item.",
+          "name": "findDragHandle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "description": "Used to get the text displayed next to the copy icon button when \`variant='inline'\`.
-Returns either the \`textToCopy\` value or the \`textToDisplay\` value if it has been set.",
-          "name": "findDisplayedText",
+          "description": "Returns the text label displayed in the option item.",
+          "name": "findLabel",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -97224,30 +97155,12 @@ Returns either the \`textToCopy\` value or the \`textToDisplay\` value if it has
           },
         },
         {
-          "name": "findStatusText",
-          "parameters": [
-            {
-              "defaultValue": "{
-    popoverRenderWithPortal: false
-  }",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ popoverRenderWithPortal: boolean; }",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findTextToCopy",
+          "description": "Returns the visibility toggle for the option item.",
+          "name": "findVisibilityToggle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ToggleWrapper",
           },
         },
         {
@@ -97292,7 +97205,7 @@ Returns either the \`textToCopy\` value or the \`textToDisplay\` value if it has
           },
         },
       ],
-      "name": "CopyToClipboardWrapper",
+      "name": "ContentDisplayOptionWrapper",
     },
     {
       "methods": [
@@ -97467,10 +97380,71 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseInputWrapper.findNativeInput",
+          "name": "findEditor",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
           },
-          "name": "findNativeInput",
+        },
+        {
+          "name": "findErrorScreen",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findErrorsTab",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findLoadingScreen",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findNativeTextArea",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findPane",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findSettingsButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "name": "findStatusBar",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findWarningsTab",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -97519,7 +97493,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "DateInputWrapper",
+      "name": "CodeEditorWrapper",
     },
     {
       "methods": [
@@ -97663,28 +97637,21 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "name": "findCalendar",
+          "description": "Returns a column from the grid for a given index.",
+          "inheritedFrom": {
+            "name": "GridWrapper.findColumn",
+          },
+          "name": "findColumn",
           "parameters": [
             {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "description": "1-based index of the column to return.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
+              "name": "columnIndex",
+              "typeName": "number",
             },
           ],
-          "returnType": {
-            "isNullable": false,
-            "name": "CalendarWrapper",
-          },
-        },
-        {
-          "name": "findCalendarDropdown",
-          "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
@@ -97721,25 +97688,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
-        {
-          "inheritedFrom": {
-            "name": "BaseInputWrapper.findNativeInput",
-          },
-          "name": "findNativeInput",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findOpenCalendarButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -97782,7 +97730,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "DatePickerWrapper",
+      "name": "ColumnLayoutWrapper",
     },
     {
       "methods": [
@@ -97957,28 +97905,15 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findDropdown",
-          "parameters": [
-            {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
-            },
-          ],
+          "name": "findContent",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "DrpDropdownWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "description": "Alias for \`findTrigger\`",
-          "name": "findLabel",
+          "name": "findFooter",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -97986,8 +97921,15 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns the trigger element that can be used to open the picker dropdown.",
-          "name": "findTrigger",
+          "name": "findHeader",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findMedia",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -98036,7 +97978,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "DateRangePickerWrapper",
+      "name": "ContainerWrapper",
     },
     {
       "methods": [
@@ -98161,11 +98103,11 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "name": "findApplyButton",
+          "name": "findBreadcrumbs",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
@@ -98187,22 +98129,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findCancelButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
-        {
-          "name": "findClearButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -98235,215 +98161,292 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns the day container that corresponds to the current day.",
-          "name": "findCurrentDay",
+          "name": "findContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "CalendarDateWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "description": "Returns the month container that corresponds to the current month.",
-          "name": "findCurrentMonth",
+          "name": "findHeader",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "CalendarDateWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findCustomRelativeRangeDuration",
+          "name": "findNotifications",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "InputWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findCustomRelativeRangeUnit",
+          "name": "findSecondaryHeader",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "SelectWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "description": "Returns a day container on the calendar.",
-          "name": "findDateAt",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
           "parameters": [
             {
-              "description": "the calendar grid. If only one calendar grid is visible (on small screens), use \`'right'\`.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "grid",
-              "typeName": ""left" | "right"",
-            },
-            {
-              "description": "1-based row index of the day.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "row",
-              "typeName": "2 | 1 | 3 | 4 | 5 | 6",
-            },
-            {
-              "description": "1-based column index of the day.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "column",
-              "typeName": "2 | 1 | 3 | 4 | 5 | 6 | 7",
+              "name": "selector",
+              "typeName": "string",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "CalendarDateWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findEndDateInput",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "InputWrapper",
-          },
-        },
-        {
-          "name": "findEndTimeInput",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "InputWrapper",
+            "name": "string",
           },
         },
+      ],
+      "name": "ContentLayoutWrapper",
+    },
+    {
+      "methods": [
         {
-          "name": "findHeader",
-          "parameters": [],
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
         {
-          "description": "Returns a month container on the calendar.",
-          "name": "findMonthAt",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
           "parameters": [
             {
-              "description": "the calendar grid. If only one calendar grid is visible (on small screens), use \`'right'\`.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "grid",
-              "typeName": ""left" | "right"",
+              "name": "selector",
+              "typeName": "string",
             },
-            {
-              "description": "1-based row index of the month.",
-              "flags": {
-                "isOptional": false,
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
               },
-              "name": "row",
-              "typeName": "2 | 1 | 3 | 4",
-            },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
             {
-              "description": "1-based column index of the month.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "column",
-              "typeName": "2 | 1 | 3",
+              "name": "className",
+              "typeName": "string",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "CalendarDateWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findNextButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
           },
-        },
-        {
-          "description": "Alias for findNextButton for compatibility with previous versions.",
-          "name": "findNextMonthButton",
-          "parameters": [],
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findPreviousButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
           },
-        },
-        {
-          "description": "Alias for findPreviousButton for compatibility with previous versions.",
-          "name": "findPreviousMonthButton",
-          "parameters": [],
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findRelativeRangeRadioGroup",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "RadioGroupWrapper",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
           },
-        },
-        {
-          "name": "findSelectedEndDate",
-          "parameters": [],
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
         {
-          "name": "findSelectedStartDate",
-          "parameters": [],
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "Wrapper",
           },
         },
         {
-          "name": "findSelectionModeSwitch",
+          "name": "findCopyButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "SelectionModeSwitchWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
-          "name": "findStartDateInput",
+          "description": "Used to get the text displayed next to the copy icon button when \`variant='inline'\`.
+Returns either the \`textToCopy\` value or the \`textToDisplay\` value if it has been set.",
+          "name": "findDisplayedText",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "InputWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findStartTimeInput",
-          "parameters": [],
+          "name": "findStatusText",
+          "parameters": [
+            {
+              "defaultValue": "{
+    popoverRenderWithPortal: false
+  }",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ popoverRenderWithPortal: boolean; }",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "InputWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findValidationError",
+          "name": "findTextToCopy",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -98492,7 +98495,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "DrpDropdownWrapper",
+      "name": "CopyToClipboardWrapper",
     },
     {
       "methods": [
@@ -98667,24 +98670,14 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns the mode selector as a SegmentedControl wrapper.
-
-The mode selector is only rendered as a SegmentedControl on wide viewports. On narrow viewports, use \`findModesAsSelect()\` instead.",
-          "name": "findModesAsSegments",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "SegmentedControlWrapper",
+          "inheritedFrom": {
+            "name": "BaseInputWrapper.findNativeInput",
           },
-        },
-        {
-          "description": "Returns the mode selector as a Select wrapper.
-The mode selector is only rendered as a Select on narrow viewports. On wide viewports, use \`findModesAsSegments()\` instead.",
-          "name": "findModesAsSelect",
+          "name": "findNativeInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "SelectWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
@@ -98729,7 +98722,7 @@ The mode selector is only rendered as a Select on narrow viewports. On wide view
           },
         },
       ],
-      "name": "SelectionModeSwitchWrapper",
+      "name": "DateInputWrapper",
     },
     {
       "methods": [
@@ -98873,73 +98866,81 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
-
-Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
-          "inheritedFrom": {
-            "name": "AbstractWrapper.findComponent",
-          },
-          "name": "findComponent",
+          "name": "findCalendar",
           "parameters": [
             {
-              "description": "CSS selector",
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "selector",
-              "typeName": "string",
-            },
-            {
-              "description": "Component's wrapper class",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "ComponentClass",
-              "typeName": "WrapperClass<Wrapper>",
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "Wrapper",
+            "name": "CalendarWrapper",
           },
         },
         {
-          "description": "Finds the segment with the given ID.",
-          "name": "findSegmentById",
+          "name": "findCalendarDropdown",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
           "parameters": [
             {
-              "description": "ID of the element to return.",
+              "description": "CSS selector",
               "flags": {
                 "isOptional": false,
               },
-              "name": "id",
+              "name": "selector",
               "typeName": "string",
             },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "SegmentWrapper",
+            "name": "Wrapper",
           },
         },
         {
-          "name": "findSegments",
+          "inheritedFrom": {
+            "name": "BaseInputWrapper.findNativeInput",
+          },
+          "name": "findNativeInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findSelectedSegment",
+          "name": "findOpenCalendarButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
@@ -98984,7 +98985,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "SegmentedControlWrapper",
+      "name": "DatePickerWrapper",
     },
     {
       "methods": [
@@ -99159,7 +99160,37 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findDisabledReason",
+          "name": "findDropdown",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "DrpDropdownWrapper",
+          },
+        },
+        {
+          "description": "Alias for \`findTrigger\`",
+          "name": "findLabel",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns the trigger element that can be used to open the picker dropdown.",
+          "name": "findTrigger",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -99208,7 +99239,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "SegmentWrapper",
+      "name": "DateRangePickerWrapper",
     },
     {
       "methods": [
@@ -99332,6 +99363,14 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findApplyButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -99351,6 +99390,22 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findCancelButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "name": "findClearButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -99383,79 +99438,91 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "DropdownHostComponentWrapper.findDropdown",
+          "description": "Returns the day container that corresponds to the current day.",
+          "name": "findCurrentDay",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "CalendarDateWrapper",
           },
-          "name": "findDropdown",
-          "parameters": [
-            {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
-            },
-          ],
+        },
+        {
+          "description": "Returns the month container that corresponds to the current month.",
+          "name": "findCurrentMonth",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "DropdownContentWrapper",
+            "name": "CalendarDateWrapper",
           },
         },
         {
-          "name": "findErrorRecoveryButton",
-          "parameters": [
-            {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
-            },
-          ],
+          "name": "findCustomRelativeRangeDuration",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "InputWrapper",
           },
         },
         {
-          "description": "Returns the input that is used for filtering.",
-          "name": "findFilteringInput",
+          "name": "findCustomRelativeRangeUnit",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "SelectWrapper",
+          },
+        },
+        {
+          "description": "Returns a day container on the calendar.",
+          "name": "findDateAt",
           "parameters": [
             {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "description": "the calendar grid. If only one calendar grid is visible (on small screens), use \`'right'\`.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
+              "name": "grid",
+              "typeName": ""left" | "right"",
+            },
+            {
+              "description": "1-based row index of the day.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "row",
+              "typeName": "2 | 1 | 3 | 4 | 5 | 6",
+            },
+            {
+              "description": "1-based column index of the day.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "column",
+              "typeName": "2 | 1 | 3 | 4 | 5 | 6 | 7",
             },
           ],
+          "returnType": {
+            "isNullable": false,
+            "name": "CalendarDateWrapper",
+          },
+        },
+        {
+          "name": "findEndDateInput",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "InputWrapper",
           },
         },
         {
-          "name": "findInlineLabel",
+          "name": "findEndTimeInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "InputWrapper",
           },
         },
         {
-          "name": "findPlaceholder",
+          "name": "findHeader",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -99463,48 +99530,144 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findStatusIndicator",
+          "description": "Returns a month container on the calendar.",
+          "name": "findMonthAt",
           "parameters": [
             {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "description": "the calendar grid. If only one calendar grid is visible (on small screens), use \`'right'\`.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
+              "name": "grid",
+              "typeName": ""left" | "right"",
+            },
+            {
+              "description": "1-based row index of the month.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "row",
+              "typeName": "2 | 1 | 3 | 4",
+            },
+            {
+              "description": "1-based column index of the month.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "column",
+              "typeName": "2 | 1 | 3",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "CalendarDateWrapper",
           },
         },
         {
-          "name": "findTrigger",
+          "name": "findNextButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.getElement",
-          },
-          "name": "getElement",
+          "description": "Alias for findNextButton for compatibility with previous versions.",
+          "name": "findNextMonthButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "string",
+            "name": "ButtonWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.matches",
-          },
+          "name": "findPreviousButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "description": "Alias for findPreviousButton for compatibility with previous versions.",
+          "name": "findPreviousMonthButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "name": "findRelativeRangeRadioGroup",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "RadioGroupWrapper",
+          },
+        },
+        {
+          "name": "findSelectedEndDate",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findSelectedStartDate",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findSelectionModeSwitch",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "SelectionModeSwitchWrapper",
+          },
+        },
+        {
+          "name": "findStartDateInput",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "InputWrapper",
+          },
+        },
+        {
+          "name": "findStartTimeInput",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "InputWrapper",
+          },
+        },
+        {
+          "name": "findValidationError",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
           "name": "matches",
           "parameters": [
             {
@@ -99532,7 +99695,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "SelectWrapper",
+      "name": "DrpDropdownWrapper",
     },
     {
       "methods": [
@@ -99707,27 +99870,24 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findContent",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findHeader",
+          "description": "Returns the mode selector as a SegmentedControl wrapper.
+
+The mode selector is only rendered as a SegmentedControl on wide viewports. On narrow viewports, use \`findModesAsSelect()\` instead.",
+          "name": "findModesAsSegments",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "SegmentedControlWrapper",
           },
         },
         {
-          "name": "findHeaderActions",
+          "description": "Returns the mode selector as a Select wrapper.
+The mode selector is only rendered as a Select on narrow viewports. On wide viewports, use \`findModesAsSegments()\` instead.",
+          "name": "findModesAsSelect",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "SelectWrapper",
           },
         },
         {
@@ -99772,7 +99932,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "DrawerWrapper",
+      "name": "SelectionModeSwitchWrapper",
     },
     {
       "methods": [
@@ -99947,55 +100107,38 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findContent",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findExpandButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findExpandedContent",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findExpandIcon",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findHeader",
-          "parameters": [],
+          "description": "Finds the segment with the given ID.",
+          "name": "findSegmentById",
+          "parameters": [
+            {
+              "description": "ID of the element to return.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "SegmentWrapper",
           },
         },
         {
-          "name": "findHeaderDescription",
+          "name": "findSegments",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findHeaderText",
+          "name": "findSelectedSegment",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -100044,7 +100187,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ExpandableSectionWrapper",
+      "name": "SegmentedControlWrapper",
     },
     {
       "methods": [
@@ -100219,7 +100362,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findContent",
+          "name": "findDisabledReason",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -100268,7 +100411,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "FileDropzoneWrapper",
+      "name": "SegmentWrapper",
     },
     {
       "methods": [
@@ -100443,85 +100586,163 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns a file token from for a given index.",
-          "name": "findFileToken",
+          "inheritedFrom": {
+            "name": "DropdownHostComponentWrapper.findDropdown",
+          },
+          "name": "findDropdown",
           "parameters": [
             {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "fileTokenIndex",
-              "typeName": "number",
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "FileTokenWrapper",
+            "name": "DropdownContentWrapper",
           },
         },
         {
-          "name": "findFileTokens",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "FileTokenWrapper",
+          "name": "findErrorRecoveryButton",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
               },
-            ],
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.getElement",
-          },
-          "name": "getElement",
-          "parameters": [],
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "string",
+            "name": "ElementWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.matches",
-          },
-          "name": "matches",
+          "description": "Returns the input that is used for filtering.",
+          "name": "findFilteringInput",
           "parameters": [
             {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "selector",
-              "typeName": "string",
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "InputWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.toSelector",
-          },
-          "name": "toSelector",
+          "name": "findInlineLabel",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "string",
+            "name": "ElementWrapper",
           },
         },
-      ],
-      "name": "FileTokenGroupWrapper",
-    },
-    {
-      "methods": [
         {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.find",
-          },
+          "name": "findPlaceholder",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findStatusIndicator",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findTrigger",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "SelectWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
           "name": "find",
           "parameters": [
             {
@@ -100689,39 +100910,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findFileError",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findFileLastModified",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findFileName",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findFileSize",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findFileThumbnail",
+          "name": "findContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -100729,7 +100918,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findFileWarning",
+          "name": "findHeader",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -100737,7 +100926,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findRemoveButton",
+          "name": "findHeaderActions",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -100786,7 +100975,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "FileTokenWrapper",
+      "name": "DrawerWrapper",
     },
     {
       "methods": [
@@ -100961,7 +101150,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findConstraint",
+          "name": "findContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -100969,7 +101158,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findError",
+          "name": "findExpandButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -100977,37 +101166,15 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns a file token from for a given index.",
-          "name": "findFileToken",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "fileTokenIndex",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "FileTokenWrapper",
-          },
-        },
-        {
-          "name": "findFileTokens",
+          "name": "findExpandedContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "FileTokenWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findNativeInput",
+          "name": "findExpandIcon",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -101015,8 +101182,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns the token toggle button.",
-          "name": "findTokenToggle",
+          "name": "findHeader",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -101024,15 +101190,15 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findUploadButton",
+          "name": "findHeaderDescription",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findWarning",
+          "name": "findHeaderText",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -101081,7 +101247,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "FileUploadWrapper",
+      "name": "ExpandableSectionWrapper",
     },
     {
       "methods": [
@@ -101256,50 +101422,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns the individual flashes of this flashbar.
-
-If the items are stacked, only the item at the top of the stack is returned.",
-          "name": "findItems",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "FlashWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "description": "Returns the individual flashes of this flashbar given the item type.
-
-If the items are stacked, only the item at the top of the stack is returned.
-
-If an item is loading its type is considered as "info".",
-          "name": "findItemsByType",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "type",
-              "typeName": ""error" | "success" | "info" | "warning"",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "FlashWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "description": "Returns the toggle button that expands and collapses stacked notifications.",
-          "name": "findToggleButton",
+          "name": "findContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -101348,7 +101471,7 @@ If an item is loading its type is considered as "info".",
           },
         },
       ],
-      "name": "FlashbarWrapper",
+      "name": "FileDropzoneWrapper",
     },
     {
       "methods": [
@@ -101371,14 +101494,6 @@ If an item is loading its type is considered as "info".",
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findActions",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -101531,46 +101646,44 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findContent",
-          "parameters": [],
+          "description": "Returns a file token from for a given index.",
+          "name": "findFileToken",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "fileTokenIndex",
+              "typeName": "number",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "FileTokenWrapper",
           },
         },
         {
-          "name": "findError",
+          "name": "findFileTokens",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "FileTokenWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findHeader",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findSecondaryActions",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.getElement",
-          },
-          "name": "getElement",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "string",
+            "name": "string",
           },
         },
         {
@@ -101604,7 +101717,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "FormWrapper",
+      "name": "FileTokenGroupWrapper",
     },
     {
       "methods": [
@@ -101747,24 +101860,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "description": "Returns a column from the grid for a given index.",
-          "name": "findColumn",
-          "parameters": [
-            {
-              "description": "1-based index of the column to return.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "columnIndex",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -101796,6 +101891,62 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
+        {
+          "name": "findFileError",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findFileLastModified",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findFileName",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findFileSize",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findFileThumbnail",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findFileWarning",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findRemoveButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -101838,7 +101989,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "GridWrapper",
+      "name": "FileTokenWrapper",
     },
     {
       "methods": [
@@ -101861,14 +102012,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findActions",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -102021,7 +102164,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findCounter",
+          "name": "findConstraint",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -102029,7 +102172,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findDescription",
+          "name": "findError",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -102037,7 +102180,37 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findHeadingText",
+          "description": "Returns a file token from for a given index.",
+          "name": "findFileToken",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "fileTokenIndex",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "FileTokenWrapper",
+          },
+        },
+        {
+          "name": "findFileTokens",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "FileTokenWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "name": "findNativeInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -102045,7 +102218,24 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findInfo",
+          "description": "Returns the token toggle button.",
+          "name": "findTokenToggle",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findUploadButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "name": "findWarning",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -102094,7 +102284,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "HeaderWrapper",
+      "name": "FileUploadWrapper",
     },
     {
       "methods": [
@@ -102269,23 +102459,50 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findContent",
+          "description": "Returns the individual flashes of this flashbar.
+
+If the items are stacked, only the item at the top of the stack is returned.",
+          "name": "findItems",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "FlashWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findFooter",
-          "parameters": [],
+          "description": "Returns the individual flashes of this flashbar given the item type.
+
+If the items are stacked, only the item at the top of the stack is returned.
+
+If an item is loading its type is considered as "info".",
+          "name": "findItemsByType",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "type",
+              "typeName": ""error" | "success" | "info" | "warning"",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "FlashWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findHeader",
+          "description": "Returns the toggle button that expands and collapses stacked notifications.",
+          "name": "findToggleButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -102334,7 +102551,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "HelpPanelWrapper",
+      "name": "FlashbarWrapper",
     },
     {
       "methods": [
@@ -102357,6 +102574,26 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
+        {
+          "description": "Returns the action slot.",
+          "name": "findAction",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns the action button.
+
+The action button is only rendered when the \`buttonText\` property is set.",
+          "name": "findActionButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -102439,14 +102676,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             ],
           },
         },
-        {
-          "name": "findAnnotation",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "AnnotationWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAny",
@@ -102517,7 +102746,26 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findTrigger",
+          "name": "findContent",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns the dismiss button.
+
+The dismiss button is only rendered when the \`dismissible\` property is set to \`true\`.",
+          "name": "findDismissButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "name": "findHeader",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -102566,7 +102814,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "HotspotWrapper",
+      "name": "FlashWrapper",
     },
     {
       "methods": [
@@ -102590,10 +102838,18 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.findAll",
-          },
-          "name": "findAll",
+          "name": "findActions",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
           "parameters": [
             {
               "flags": {
@@ -102740,6 +102996,38 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
+        {
+          "name": "findContent",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findError",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findHeader",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findSecondaryActions",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -102782,7 +103070,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "IconWrapper",
+      "name": "FormWrapper",
     },
     {
       "methods": [
@@ -102925,6 +103213,24 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "description": "Returns a column from the grid for a given index.",
+          "name": "findColumn",
+          "parameters": [
+            {
+              "description": "1-based index of the column to return.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "columnIndex",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -102956,19 +103262,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
-        {
-          "name": "findItems",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "KeyValuePairsItemWrapper",
-              },
-            ],
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -103011,7 +103304,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "KeyValuePairsWrapper",
+      "name": "GridWrapper",
     },
     {
       "methods": [
@@ -103034,6 +103327,14 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findActions",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -103135,18 +103436,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "description": "Returns a focusable element that controls keyboard interactions.",
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findApplication",
-          },
-          "name": "findApplication",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -103166,17 +103455,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findChart",
-          },
-          "name": "findChart",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -103209,43 +103487,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "CommonChartWrapper.findDefaultFilter",
-          },
-          "name": "findDefaultFilter",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ChartFilterWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "CommonChartWrapper.findDetailPopover",
-          },
-          "name": "findDetailPopover",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ChartPopoverWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findFilterContainer",
-          },
-          "name": "findFilterContainer",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findHighlightedSeries",
-          },
-          "name": "findHighlightedSeries",
+          "name": "findCounter",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -103253,38 +103495,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "CommonChartWrapper.findLegend",
-          },
-          "name": "findLegend",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ChartLegendWrapper",
-          },
-        },
-        {
-          "description": "Returns an array of chart series. Note that thresholds count as series as well.",
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findSeries",
-          },
-          "name": "findSeries",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "CommonChartWrapper.findStatusContainer",
-          },
-          "name": "findStatusContainer",
+          "name": "findDescription",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -103292,10 +103503,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findXAxisTitle",
-          },
-          "name": "findXAxisTitle",
+          "name": "findHeadingText",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -103303,48 +103511,13 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findXTicks",
-          },
-          "name": "findXTicks",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findYAxisTitle",
-          },
-          "name": "findYAxisTitle",
+          "name": "findInfo",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
-        {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findYTicks",
-          },
-          "name": "findYTicks",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -103387,7 +103560,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "LineChartWrapper",
+      "name": "HeaderWrapper",
     },
     {
       "methods": [
@@ -103561,6 +103734,30 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
+        {
+          "name": "findContent",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findFooter",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findHeader",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -103603,7 +103800,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "LinkWrapper",
+      "name": "HelpPanelWrapper",
     },
     {
       "methods": [
@@ -103709,11 +103906,19 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.findAny",
-          },
-          "name": "findAny",
-          "parameters": [
+          "name": "findAnnotation",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "AnnotationWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
             {
               "flags": {
                 "isOptional": false,
@@ -103778,52 +103983,11 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns an item for a given id.",
-          "name": "findItemById",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "id",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ListItemWrapper",
-          },
-        },
-        {
-          "description": "Returns an item for a given index.",
-          "name": "findItemByIndex",
-          "parameters": [
-            {
-              "description": "1-based index of the item to return.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "index",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ListItemWrapper",
-          },
-        },
-        {
-          "description": "Returns all list items.",
-          "name": "findItems",
+          "name": "findTrigger",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ListItemWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
@@ -103868,7 +104032,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ListWrapper",
+      "name": "HotspotWrapper",
     },
     {
       "methods": [
@@ -103891,17 +104055,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
-        {
-          "inheritedFrom": {
-            "name": "StructuredItemWrapper.findActions",
-          },
-          "name": "findActions",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -104053,47 +104206,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
-        {
-          "inheritedFrom": {
-            "name": "StructuredItemWrapper.findContent",
-          },
-          "name": "findContent",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findDragHandle",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "StructuredItemWrapper.findIcon",
-          },
-          "name": "findIcon",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "StructuredItemWrapper.findSecondaryContent",
-          },
-          "name": "findSecondaryContent",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -104136,7 +104248,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ListItemWrapper",
+      "name": "IconWrapper",
     },
     {
       "methods": [
@@ -104310,6 +104422,19 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
+        {
+          "name": "findItems",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "KeyValuePairsItemWrapper",
+              },
+            ],
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -104352,7 +104477,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "LiveRegionWrapper",
+      "name": "KeyValuePairsWrapper",
     },
     {
       "methods": [
@@ -104476,32 +104601,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "description": "Returns a focusable element that controls keyboard interactions.",
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findApplication",
-          },
-          "name": "findApplication",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Returns an array of bar groups, which are used for mouse navigation if a chart contains bar series.",
-          "name": "findBarGroups",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -104521,17 +104620,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findChart",
-          },
-          "name": "findChart",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -104564,32 +104652,31 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "CommonChartWrapper.findDefaultFilter",
-          },
-          "name": "findDefaultFilter",
+          "name": "findGroupPairs",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ChartFilterWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "KeyValuePairsPairWrapper",
+              },
+            ],
           },
         },
         {
-          "inheritedFrom": {
-            "name": "CommonChartWrapper.findDetailPopover",
-          },
-          "name": "findDetailPopover",
+          "name": "findGroupTitle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ChartPopoverWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
           "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findFilterContainer",
+            "name": "KeyValuePairsPairWrapper.findInfo",
           },
-          "name": "findFilterContainer",
+          "name": "findInfo",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -104598,9 +104685,9 @@ Note: This function returns the specified component's wrapper even if the specif
         },
         {
           "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findHighlightedSeries",
+            "name": "KeyValuePairsPairWrapper.findLabel",
           },
-          "name": "findHighlightedSeries",
+          "name": "findLabel",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -104609,38 +104696,40 @@ Note: This function returns the specified component's wrapper even if the specif
         },
         {
           "inheritedFrom": {
-            "name": "CommonChartWrapper.findLegend",
+            "name": "KeyValuePairsPairWrapper.findValue",
           },
-          "name": "findLegend",
+          "name": "findValue",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ChartLegendWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "description": "Returns an array of chart series. Note that thresholds count as series as well.",
           "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findSeries",
+            "name": "AbstractWrapper.getElement",
           },
-          "name": "findSeries",
+          "name": "getElement",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
+            "name": "string",
           },
         },
         {
           "inheritedFrom": {
-            "name": "CommonChartWrapper.findStatusContainer",
+            "name": "AbstractWrapper.matches",
           },
-          "name": "findStatusContainer",
-          "parameters": [],
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
@@ -104648,118 +104737,34 @@ Note: This function returns the specified component's wrapper even if the specif
         },
         {
           "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findXAxisTitle",
+            "name": "AbstractWrapper.toSelector",
           },
-          "name": "findXAxisTitle",
+          "name": "toSelector",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "string",
           },
         },
+      ],
+      "name": "KeyValuePairsItemWrapper",
+    },
+    {
+      "methods": [
         {
           "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findXTicks",
+            "name": "AbstractWrapper.find",
           },
-          "name": "findXTicks",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findYAxisTitle",
-          },
-          "name": "findYAxisTitle",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "BaseCartesianChartWrapper.findYTicks",
-          },
-          "name": "findYTicks",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.getElement",
-          },
-          "name": "getElement",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "string",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.matches",
-          },
-          "name": "matches",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "selector",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.toSelector",
-          },
-          "name": "toSelector",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "string",
-          },
-        },
-      ],
-      "name": "MixedLineBarChartWrapper",
-    },
-    {
-      "methods": [
-        {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.find",
-          },
-          "name": "find",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "selector",
-              "typeName": "string",
-            },
-          ],
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
@@ -104917,15 +104922,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findContent",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findDismissButton",
+          "name": "findInfo",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -104933,7 +104930,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findFooter",
+          "name": "findLabel",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -104941,7 +104938,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findHeader",
+          "name": "findValue",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -104990,7 +104987,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "ModalWrapper",
+      "name": "KeyValuePairsPairWrapper",
     },
     {
       "methods": [
@@ -105114,6 +105111,18 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "description": "Returns a focusable element that controls keyboard interactions.",
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findApplication",
+          },
+          "name": "findApplication",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -105133,6 +105142,17 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findChart",
+          },
+          "name": "findChart",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -105166,70 +105186,31 @@ Note: This function returns the specified component's wrapper even if the specif
         },
         {
           "inheritedFrom": {
-            "name": "DropdownHostComponentWrapper.findDropdown",
+            "name": "CommonChartWrapper.findDefaultFilter",
           },
-          "name": "findDropdown",
-          "parameters": [
-            {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
-            },
-          ],
+          "name": "findDefaultFilter",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "DropdownContentWrapper",
+            "name": "ChartFilterWrapper",
           },
         },
         {
-          "name": "findErrorRecoveryButton",
-          "parameters": [
-            {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
+          "inheritedFrom": {
+            "name": "CommonChartWrapper.findDetailPopover",
           },
-        },
-        {
-          "description": "Returns the input that is used for filtering.",
-          "name": "findFilteringInput",
-          "parameters": [
-            {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
-            },
-          ],
+          "name": "findDetailPopover",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "InputWrapper",
+            "name": "ChartPopoverWrapper",
           },
         },
         {
-          "name": "findInlineLabel",
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findFilterContainer",
+          },
+          "name": "findFilterContainer",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -105237,7 +105218,10 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findPlaceholder",
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findHighlightedSeries",
+          },
+          "name": "findHighlightedSeries",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -105245,59 +105229,38 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findStatusIndicator",
-          "parameters": [
-            {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
+          "inheritedFrom": {
+            "name": "CommonChartWrapper.findLegend",
           },
-        },
-        {
-          "description": "Returns a token.",
-          "name": "findToken",
-          "parameters": [
-            {
-              "description": "1-based index of the token to return",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "tokenIndex",
-              "typeName": "number",
-            },
-          ],
+          "name": "findLegend",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "TokenWrapper",
+            "name": "ChartLegendWrapper",
           },
         },
         {
-          "name": "findTokens",
+          "description": "Returns an array of chart series. Note that thresholds count as series as well.",
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findSeries",
+          },
+          "name": "findSeries",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "MultiElementWrapper",
             "typeArguments": [
               {
-                "name": "TokenWrapper",
+                "name": "ElementWrapper",
               },
             ],
           },
         },
         {
-          "description": "Returns a token toggle button.",
-          "name": "findTokenToggle",
+          "inheritedFrom": {
+            "name": "CommonChartWrapper.findStatusContainer",
+          },
+          "name": "findStatusContainer",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -105305,13 +105268,59 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findTrigger",
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findXAxisTitle",
+          },
+          "name": "findXAxisTitle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findXTicks",
+          },
+          "name": "findXTicks",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findYAxisTitle",
+          },
+          "name": "findYAxisTitle",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findYTicks",
+          },
+          "name": "findYTicks",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -105354,7 +105363,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "MultiselectWrapper",
+      "name": "LineChartWrapper",
     },
     {
       "methods": [
@@ -105528,30 +105537,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
-        {
-          "name": "findDismiss",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findLabel",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findOption",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "OptionWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -105594,7 +105579,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TokenWrapper",
+      "name": "LinkWrapper",
     },
     {
       "methods": [
@@ -105769,11 +105754,52 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findContent",
+          "description": "Returns an item for a given id.",
+          "name": "findItemById",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ListItemWrapper",
+          },
+        },
+        {
+          "description": "Returns an item for a given index.",
+          "name": "findItemByIndex",
+          "parameters": [
+            {
+              "description": "1-based index of the item to return.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ListItemWrapper",
+          },
+        },
+        {
+          "description": "Returns all list items.",
+          "name": "findItems",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ListItemWrapper",
+              },
+            ],
           },
         },
         {
@@ -105818,7 +105844,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "NavigableGroupWrapper",
+      "name": "ListWrapper",
     },
     {
       "methods": [
@@ -105841,6 +105867,17 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
+        {
+          "inheritedFrom": {
+            "name": "StructuredItemWrapper.findActions",
+          },
+          "name": "findActions",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -105942,15 +105979,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "description": "Returns a focusable element that controls keyboard interactions.",
-          "name": "findApplication",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -105970,14 +105998,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findChart",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -106011,44 +106031,9 @@ Note: This function returns the specified component's wrapper even if the specif
         },
         {
           "inheritedFrom": {
-            "name": "CommonChartWrapper.findDefaultFilter",
-          },
-          "name": "findDefaultFilter",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ChartFilterWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "CommonChartWrapper.findDetailPopover",
-          },
-          "name": "findDetailPopover",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ChartPopoverWrapper",
-          },
-        },
-        {
-          "name": "findFilterContainer",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findHighlightedSegment",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "StructuredItemWrapper.findContent",
           },
-        },
-        {
-          "name": "findHighlightedSegmentLabel",
+          "name": "findContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -106056,7 +106041,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findInnerContent",
+          "name": "findDragHandle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -106065,46 +106050,20 @@ Note: This function returns the specified component's wrapper even if the specif
         },
         {
           "inheritedFrom": {
-            "name": "CommonChartWrapper.findLegend",
-          },
-          "name": "findLegend",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ChartLegendWrapper",
-          },
-        },
-        {
-          "name": "findSegmentLabels",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
+            "name": "StructuredItemWrapper.findIcon",
           },
-        },
-        {
-          "name": "findSegments",
+          "name": "findIcon",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
           "inheritedFrom": {
-            "name": "CommonChartWrapper.findStatusContainer",
+            "name": "StructuredItemWrapper.findSecondaryContent",
           },
-          "name": "findStatusContainer",
+          "name": "findSecondaryContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -106153,7 +106112,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "PieChartWrapper",
+      "name": "ListItemWrapper",
     },
     {
       "methods": [
@@ -106328,96 +106287,28 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findContent",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
           "parameters": [
             {
-              "defaultValue": "{
-    renderWithPortal: false
-  }",
-              "description": "* renderWithPortal (boolean) - Flag to find the content when the popover is rendered with a portal",
               "flags": {
                 "isOptional": false,
               },
-              "name": "options",
-              "typeName": "{ renderWithPortal: boolean; }",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findDismissButton",
-          "parameters": [
-            {
-              "defaultValue": "{
-    renderWithPortal: false
-  }",
-              "description": "* renderWithPortal (boolean) - Flag to find the dismiss button when the popover is rendered with a portal",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ renderWithPortal: boolean; }",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
-        {
-          "name": "findHeader",
-          "parameters": [
-            {
-              "defaultValue": "{
-    renderWithPortal: false
-  }",
-              "description": "* renderWithPortal (boolean) - Flag to find the header when the popover is rendered with a portal",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ renderWithPortal: boolean; }",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findTrigger",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.getElement",
-          },
-          "name": "getElement",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "string",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.matches",
-          },
-          "name": "matches",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "selector",
-              "typeName": "string",
+              "name": "selector",
+              "typeName": "string",
             },
           ],
           "returnType": {
@@ -106437,7 +106328,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "PopoverWrapper",
+      "name": "LiveRegionWrapper",
     },
     {
       "methods": [
@@ -106460,14 +106351,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findAdditionalInfo",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -106569,6 +106452,32 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "description": "Returns a focusable element that controls keyboard interactions.",
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findApplication",
+          },
+          "name": "findApplication",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns an array of bar groups, which are used for mouse navigation if a chart contains bar series.",
+          "name": "findBarGroups",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -106588,6 +106497,17 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findChart",
+          },
+          "name": "findChart",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -106620,35 +106540,33 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findPercentageText",
+          "inheritedFrom": {
+            "name": "CommonChartWrapper.findDefaultFilter",
+          },
+          "name": "findDefaultFilter",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ChartFilterWrapper",
           },
         },
         {
-          "name": "findResultButton",
+          "inheritedFrom": {
+            "name": "CommonChartWrapper.findDetailPopover",
+          },
+          "name": "findDetailPopover",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ChartPopoverWrapper",
           },
         },
         {
-          "description": "Returns the result text.",
-          "name": "findResultText",
-          "parameters": [
-            {
-              "description": "[optional] Status of the result text. It can be aither "error" or "succes".
-If not specified, the method returns the result text that is currently displayed, independently of the result status.",
-              "flags": {
-                "isOptional": true,
-              },
-              "name": "status",
-              "typeName": "string",
-            },
-          ],
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findFilterContainer",
+          },
+          "name": "findFilterContainer",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
@@ -106656,72 +106574,59 @@ If not specified, the method returns the result text that is currently displayed
         },
         {
           "inheritedFrom": {
-            "name": "AbstractWrapper.getElement",
+            "name": "BaseCartesianChartWrapper.findHighlightedSeries",
           },
-          "name": "getElement",
+          "name": "findHighlightedSeries",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "string",
+            "name": "ElementWrapper",
           },
         },
         {
           "inheritedFrom": {
-            "name": "AbstractWrapper.matches",
+            "name": "CommonChartWrapper.findLegend",
           },
-          "name": "matches",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "selector",
-              "typeName": "string",
-            },
-          ],
+          "name": "findLegend",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ChartLegendWrapper",
           },
         },
         {
+          "description": "Returns an array of chart series. Note that thresholds count as series as well.",
           "inheritedFrom": {
-            "name": "AbstractWrapper.toSelector",
+            "name": "BaseCartesianChartWrapper.findSeries",
           },
-          "name": "toSelector",
+          "name": "findSeries",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "string",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
-      ],
-      "name": "ProgressBarWrapper",
-    },
-    {
-      "methods": [
         {
           "inheritedFrom": {
-            "name": "AbstractWrapper.find",
+            "name": "CommonChartWrapper.findStatusContainer",
           },
-          "name": "find",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "selector",
-              "typeName": "string",
-            },
-          ],
+          "name": "findStatusContainer",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
         {
-          "description": "Finds the action button. Note that, despite its typings, this may return null.",
-          "name": "findActionButton",
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findXAxisTitle",
+          },
+          "name": "findXAxisTitle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -106730,18 +106635,10 @@ If not specified, the method returns the result text that is currently displayed
         },
         {
           "inheritedFrom": {
-            "name": "AbstractWrapper.findAll",
+            "name": "BaseCartesianChartWrapper.findXTicks",
           },
-          "name": "findAll",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "selector",
-              "typeName": "string",
-            },
-          ],
+          "name": "findXTicks",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "MultiElementWrapper",
@@ -106754,18 +106651,21 @@ If not specified, the method returns the result text that is currently displayed
         },
         {
           "inheritedFrom": {
-            "name": "AbstractWrapper.findAllByClassName",
+            "name": "BaseCartesianChartWrapper.findYAxisTitle",
           },
-          "name": "findAllByClassName",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "className",
-              "typeName": "string",
-            },
-          ],
+          "name": "findYAxisTitle",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "BaseCartesianChartWrapper.findYTicks",
+          },
+          "name": "findYTicks",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "MultiElementWrapper",
@@ -106777,15 +106677,128 @@ If not specified, the method returns the result text that is currently displayed
           },
         },
         {
-          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
-If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
           "inheritedFrom": {
-            "name": "AbstractWrapper.findAllComponents",
+            "name": "AbstractWrapper.getElement",
           },
-          "name": "findAllComponents",
-          "parameters": [
-            {
-              "flags": {
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "MixedLineBarChartWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
                 "isOptional": false,
               },
               "name": "ComponentClass",
@@ -106880,7 +106893,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findCustomPrimaryAction",
+          "name": "findContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -106888,7 +106901,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findNativeTextarea",
+          "name": "findDismissButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -106896,8 +106909,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Finds the secondary actions slot. Note that, despite its typings, this may return null.",
-          "name": "findSecondaryActions",
+          "name": "findFooter",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -106905,7 +106917,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findSecondaryContent",
+          "name": "findHeader",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -106954,7 +106966,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "PromptInputWrapper",
+      "name": "ModalWrapper",
     },
     {
       "methods": [
@@ -107097,17 +107109,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "inheritedFrom": {
-            "name": "InputWrapper.findClearButton",
-          },
-          "name": "findClearButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -107139,36 +107140,9 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
-        {
-          "description": "Returns the element containing the \`filteringConstraintText\` slot.",
-          "name": "findConstraint",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Returns the element containing the \`customControl\` slot.",
-          "name": "findCustomControl",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Returns the element containing the \`customFilterActions\` slot.",
-          "name": "findCustomFilterActions",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
-            "name": "AutosuggestWrapper.findDropdown",
+            "name": "DropdownHostComponentWrapper.findDropdown",
           },
           "name": "findDropdown",
           "parameters": [
@@ -107186,14 +107160,11 @@ Note: This function returns the specified component's wrapper even if the specif
           ],
           "returnType": {
             "isNullable": false,
-            "name": "AutosuggestDropdownWrapper",
+            "name": "DropdownContentWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AutosuggestWrapper.findEnteredTextOption",
-          },
-          "name": "findEnteredTextOption",
+          "name": "findErrorRecoveryButton",
           "parameters": [
             {
               "defaultValue": "{
@@ -107213,10 +107184,8 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AutosuggestWrapper.findErrorRecoveryButton",
-          },
-          "name": "findErrorRecoveryButton",
+          "description": "Returns the input that is used for filtering.",
+          "name": "findFilteringInput",
           "parameters": [
             {
               "defaultValue": "{
@@ -107232,14 +107201,11 @@ Note: This function returns the specified component's wrapper even if the specif
           ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "InputWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseInputWrapper.findNativeInput",
-          },
-          "name": "findNativeInput",
+          "name": "findInlineLabel",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -107247,29 +107213,15 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns custom property form cancel button.",
-          "name": "findPropertyCancelButton",
-          "parameters": [
-            {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
-            },
-          ],
+          "name": "findPlaceholder",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "description": "Returns custom property form submit button.",
-          "name": "findPropertySubmitButton",
+          "name": "findStatusIndicator",
           "parameters": [
             {
               "defaultValue": "{
@@ -107283,49 +107235,27 @@ Note: This function returns the specified component's wrapper even if the specif
               "typeName": "{ expandToViewport: boolean; }",
             },
           ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
-        {
-          "description": "Returns the button that removes all current tokens.",
-          "name": "findRemoveAllButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findResultsCount",
-          "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AutosuggestWrapper.findStatusIndicator",
-          },
-          "name": "findStatusIndicator",
+          "description": "Returns a token.",
+          "name": "findToken",
           "parameters": [
             {
-              "defaultValue": "{
-    expandToViewport: false
-  }",
-              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "description": "1-based index of the token to return",
               "flags": {
                 "isOptional": false,
               },
-              "name": "options",
-              "typeName": "{ expandToViewport: boolean; }",
+              "name": "tokenIndex",
+              "typeName": "number",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "TokenWrapper",
           },
         },
         {
@@ -107336,13 +107266,13 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "MultiElementWrapper",
             "typeArguments": [
               {
-                "name": "FilteringTokenWrapper",
+                "name": "TokenWrapper",
               },
             ],
           },
         },
         {
-          "description": "Returns the button that toggles if the tokens above \`tokenLimit\` are visible.",
+          "description": "Returns a token toggle button.",
           "name": "findTokenToggle",
           "parameters": [],
           "returnType": {
@@ -107351,14 +107281,22 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AbstractWrapper.getElement",
-          },
-          "name": "getElement",
+          "name": "findTrigger",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "string",
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
           },
         },
         {
@@ -107392,7 +107330,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "PropertyFilterWrapper",
+      "name": "MultiselectWrapper",
     },
     {
       "methods": [
@@ -107415,14 +107353,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findAlertSlot",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -107575,27 +107505,27 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findInContext",
+          "name": "findDismiss",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "S3InContextWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findModal",
+          "name": "findLabel",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "S3ModalWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findTable",
+          "name": "findOption",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "TableWrapper",
+            "name": "OptionWrapper",
           },
         },
         {
@@ -107640,7 +107570,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "S3ResourceSelectorWrapper",
+      "name": "TokenWrapper",
     },
     {
       "methods": [
@@ -107764,14 +107694,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findBrowseButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -107823,27 +107745,11 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findUriInput",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "InputWrapper",
-          },
-        },
-        {
-          "name": "findVersionsSelect",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "SelectWrapper",
-          },
-        },
-        {
-          "name": "findViewButton",
+          "name": "findContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
@@ -107888,7 +107794,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "S3InContextWrapper",
+      "name": "NavigableGroupWrapper",
     },
     {
       "methods": [
@@ -108012,6 +107918,15 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "description": "Returns a focusable element that controls keyboard interactions.",
+          "name": "findApplication",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -108031,6 +107946,14 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findChart",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -108064,20 +107987,28 @@ Note: This function returns the specified component's wrapper even if the specif
         },
         {
           "inheritedFrom": {
-            "name": "ModalWrapper.findContent",
+            "name": "CommonChartWrapper.findDefaultFilter",
           },
-          "name": "findContent",
+          "name": "findDefaultFilter",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ChartFilterWrapper",
           },
         },
         {
           "inheritedFrom": {
-            "name": "ModalWrapper.findDismissButton",
+            "name": "CommonChartWrapper.findDetailPopover",
           },
-          "name": "findDismissButton",
+          "name": "findDetailPopover",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ChartPopoverWrapper",
+          },
+        },
+        {
+          "name": "findFilterContainer",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -108085,10 +108016,23 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "ModalWrapper.findFooter",
+          "name": "findHighlightedSegment",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
           },
-          "name": "findFooter",
+        },
+        {
+          "name": "findHighlightedSegmentLabel",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findInnerContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -108097,21 +108041,50 @@ Note: This function returns the specified component's wrapper even if the specif
         },
         {
           "inheritedFrom": {
-            "name": "ModalWrapper.findHeader",
+            "name": "CommonChartWrapper.findLegend",
           },
-          "name": "findHeader",
+          "name": "findLegend",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ChartLegendWrapper",
           },
         },
         {
-          "name": "findSubmitButton",
+          "name": "findSegmentLabels",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "name": "findSegments",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "CommonChartWrapper.findStatusContainer",
+          },
+          "name": "findStatusContainer",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
           },
         },
         {
@@ -108156,7 +108129,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "S3ModalWrapper",
+      "name": "PieChartWrapper",
     },
     {
       "methods": [
@@ -108281,33 +108254,17 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "description": "Returns the column that is used for ascending sorting.",
-          "name": "findAscSortedColumn",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
           },
-        },
-        {
-          "description": "Returns a table cell based on given row and column indices.",
-          "name": "findBodyCell",
+          "name": "findByClassName",
           "parameters": [
             {
-              "description": "1-based index of the row of the cell to select.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "rowIndex",
-              "typeName": "number",
-            },
-            {
-              "description": "1-based index of the column of the cell to select.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "columnIndex",
-              "typeName": "number",
+              "name": "className",
+              "typeName": "string",
             },
           ],
           "returnType": {
@@ -108316,56 +108273,49 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
           "inheritedFrom": {
-            "name": "AbstractWrapper.findByClassName",
+            "name": "AbstractWrapper.findComponent",
           },
-          "name": "findByClassName",
+          "name": "findComponent",
           "parameters": [
             {
+              "description": "CSS selector",
               "flags": {
                 "isOptional": false,
               },
-              "name": "className",
+              "name": "selector",
               "typeName": "string",
             },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findCollectionPreferences",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "CollectionPreferencesWrapper",
-          },
-        },
-        {
-          "name": "findColumnHeaders",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
+            "name": "Wrapper",
           },
         },
         {
-          "description": "Returns the element the user clicks when resizing a column.",
-          "name": "findColumnResizer",
+          "name": "findContent",
           "parameters": [
             {
-              "description": "1-based index of the column containing the resizer.",
+              "defaultValue": "{
+    renderWithPortal: false
+  }",
+              "description": "* renderWithPortal (boolean) - Flag to find the content when the popover is rendered with a portal",
               "flags": {
                 "isOptional": false,
               },
-              "name": "columnIndex",
-              "typeName": "number",
+              "name": "options",
+              "typeName": "{ renderWithPortal: boolean; }",
             },
           ],
           "returnType": {
@@ -108374,26 +108324,3369 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "name": "findColumnSortingArea",
+          "name": "findDismissButton",
           "parameters": [
             {
+              "defaultValue": "{
+    renderWithPortal: false
+  }",
+              "description": "* renderWithPortal (boolean) - Flag to find the dismiss button when the popover is rendered with a portal",
               "flags": {
                 "isOptional": false,
               },
-              "name": "colIndex",
-              "typeName": "number",
+              "name": "options",
+              "typeName": "{ renderWithPortal: boolean; }",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
-          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
-
-Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
-          "inheritedFrom": {
+          "name": "findHeader",
+          "parameters": [
+            {
+              "defaultValue": "{
+    renderWithPortal: false
+  }",
+              "description": "* renderWithPortal (boolean) - Flag to find the header when the popover is rendered with a portal",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ renderWithPortal: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findTrigger",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "PopoverWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findAdditionalInfo",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "name": "findPercentageText",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findResultButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "description": "Returns the result text.",
+          "name": "findResultText",
+          "parameters": [
+            {
+              "description": "[optional] Status of the result text. It can be aither "error" or "succes".
+If not specified, the method returns the result text that is currently displayed, independently of the result status.",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "status",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "ProgressBarWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds the action button. Note that, despite its typings, this may return null.",
+          "name": "findActionButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "name": "findCustomPrimaryAction",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findNativeTextarea",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds the secondary actions slot. Note that, despite its typings, this may return null.",
+          "name": "findSecondaryActions",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findSecondaryContent",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "PromptInputWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "InputWrapper.findClearButton",
+          },
+          "name": "findClearButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "description": "Returns the element containing the \`filteringConstraintText\` slot.",
+          "name": "findConstraint",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns the element containing the \`customControl\` slot.",
+          "name": "findCustomControl",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns the element containing the \`customFilterActions\` slot.",
+          "name": "findCustomFilterActions",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AutosuggestWrapper.findDropdown",
+          },
+          "name": "findDropdown",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "AutosuggestDropdownWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AutosuggestWrapper.findEnteredTextOption",
+          },
+          "name": "findEnteredTextOption",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AutosuggestWrapper.findErrorRecoveryButton",
+          },
+          "name": "findErrorRecoveryButton",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "BaseInputWrapper.findNativeInput",
+          },
+          "name": "findNativeInput",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns custom property form cancel button.",
+          "name": "findPropertyCancelButton",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "description": "Returns custom property form submit button.",
+          "name": "findPropertySubmitButton",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "description": "Returns the button that removes all current tokens.",
+          "name": "findRemoveAllButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findResultsCount",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AutosuggestWrapper.findStatusIndicator",
+          },
+          "name": "findStatusIndicator",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "description": "* expandToViewport (boolean) - Use this when the component under test is rendered with an \`expandToViewport\` flag.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findTokens",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "FilteringTokenWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns the button that toggles if the tokens above \`tokenLimit\` are visible.",
+          "name": "findTokenToggle",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "PropertyFilterWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "name": "findEditButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns dropdown content of editing token if opened or \`null\` otherwise.",
+          "name": "findEditorDropdown",
+          "parameters": [
+            {
+              "defaultValue": "{
+    expandToViewport: false
+  }",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expandToViewport: boolean; }",
+            },
+          ],
+          "returnType": {
+            "isNullable": true,
+            "name": "PropertyFilterEditorDropdownWrapper",
+          },
+        },
+        {
+          "name": "findGroupTokens",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "FilteringGroupedTokenWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "name": "findLabel",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findRemoveButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findTokenOperation",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "SelectWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "FilteringTokenWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findCancelButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "name": "findDismissButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "name": "findForm",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findHeader",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findOperatorField",
+          "parameters": [
+            {
+              "defaultValue": "1",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "FormFieldWrapper",
+          },
+        },
+        {
+          "name": "findPropertyField",
+          "parameters": [
+            {
+              "defaultValue": "1",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "FormFieldWrapper",
+          },
+        },
+        {
+          "name": "findSubmitButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "name": "findTokenAddActions",
+          "parameters": [],
+          "returnType": {
+            "isNullable": true,
+            "name": "ButtonDropdownWrapper",
+          },
+        },
+        {
+          "name": "findTokenRemoveActions",
+          "parameters": [
+            {
+              "defaultValue": "1",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": true,
+            "name": "ButtonDropdownWrapper",
+          },
+        },
+        {
+          "name": "findValueField",
+          "parameters": [
+            {
+              "defaultValue": "1",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "FormFieldWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "PropertyFilterEditorDropdownWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "name": "findLabel",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findRemoveButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findTokenOperation",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "SelectWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "FilteringGroupedTokenWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findAlertSlot",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "name": "findInContext",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "S3InContextWrapper",
+          },
+        },
+        {
+          "name": "findModal",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "S3ModalWrapper",
+          },
+        },
+        {
+          "name": "findTable",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "TableWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "S3ResourceSelectorWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findBrowseButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "name": "findUriInput",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "InputWrapper",
+          },
+        },
+        {
+          "name": "findVersionsSelect",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "SelectWrapper",
+          },
+        },
+        {
+          "name": "findViewButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "S3InContextWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "ModalWrapper.findContent",
+          },
+          "name": "findContent",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "ModalWrapper.findDismissButton",
+          },
+          "name": "findDismissButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "ModalWrapper.findFooter",
+          },
+          "name": "findFooter",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "ModalWrapper.findHeader",
+          },
+          "name": "findHeader",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findSubmitButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "S3ModalWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns the column that is used for ascending sorting.",
+          "name": "findAscSortedColumn",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a table cell based on given row and column indices.",
+          "name": "findBodyCell",
+          "parameters": [
+            {
+              "description": "1-based index of the row of the cell to select.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "rowIndex",
+              "typeName": "number",
+            },
+            {
+              "description": "1-based index of the column of the cell to select.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "columnIndex",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findCollectionPreferences",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "CollectionPreferencesWrapper",
+          },
+        },
+        {
+          "name": "findColumnHeaders",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns the element the user clicks when resizing a column.",
+          "name": "findColumnResizer",
+          "parameters": [
+            {
+              "description": "1-based index of the column containing the resizer.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "columnIndex",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findColumnSortingArea",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "colIndex",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "description": "Returns the column that is used for descending sorting.",
+          "name": "findDescSortedColumn",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns the button that activates inline editing for a table cell based on given row and column indices.",
+          "name": "findEditCellButton",
+          "parameters": [
+            {
+              "description": "1-based index of the row of the cell to select.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "rowIndex",
+              "typeName": "number",
+            },
+            {
+              "description": "1-based index of the column of the cell to select.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "columnIndex",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findEditingCell",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findEditingCellCancelButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findEditingCellSaveButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Alias for findEmptySlot method for compatibility with previous versions",
+          "name": "findEmptyRegion",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findEmptySlot",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns the expandable row toggle button.",
+          "name": "findExpandToggle",
+          "parameters": [
+            {
+              "description": "1-based index of the row.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "rowIndex",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findFilterSlot",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findFooterSlot",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Alias for findHeaderSlot method for compatibility with previous versions",
+          "name": "findHeaderRegion",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findHeaderSlot",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns items loader of the specific item (matched by item's track ID).",
+          "name": "findItemsLoaderByItemId",
+          "parameters": [
+            {
+              "description": "the (expandable) item ID provided with \`trackBy\` property.
+
+Note: when used with collection-hooks the \`trackBy\` is set automatically from \`expandableRows.getId\`.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "itemId",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findLoadingText",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findPagination",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "PaginationWrapper",
+          },
+        },
+        {
+          "name": "findPropertyFilter",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "PropertyFilterWrapper",
+          },
+        },
+        {
+          "description": "Returns items loader of the root table level.",
+          "name": "findRootItemsLoader",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findRows",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a row selection area for a given index.",
+          "name": "findRowSelectionArea",
+          "parameters": [
+            {
+              "description": "1-based index of the row selection area to return.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "rowIndex",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findSelectAllTrigger",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findSelectedRows",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "name": "findTextFilter",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "TextFilterWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "string",
+          },
+        },
+      ],
+      "name": "TableWrapper",
+    },
+    {
+      "methods": [
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findActiveLink",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
             "name": "AbstractWrapper.findComponent",
           },
           "name": "findComponent",
@@ -108421,8 +111714,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns the column that is used for descending sorting.",
-          "name": "findDescSortedColumn",
+          "name": "findHeader",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -108430,33 +111722,31 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns the button that activates inline editing for a table cell based on given row and column indices.",
-          "name": "findEditCellButton",
+          "name": "findHeaderLink",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findItemByIndex",
           "parameters": [
             {
-              "description": "1-based index of the row of the cell to select.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "rowIndex",
-              "typeName": "number",
-            },
-            {
-              "description": "1-based index of the column of the cell to select.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "columnIndex",
+              "name": "index",
               "typeName": "number",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "SideNavigationItemWrapper",
           },
         },
         {
-          "name": "findEditingCell",
+          "name": "findItemsControl",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -108464,49 +111754,79 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findEditingCellCancelButton",
-          "parameters": [],
+          "name": "findLinkByHref",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "href",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
         {
-          "name": "findEditingCellSaveButton",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "string",
           },
         },
         {
-          "description": "Alias for findEmptySlot method for compatibility with previous versions",
-          "name": "findEmptyRegion",
-          "parameters": [],
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
         {
-          "name": "findEmptySlot",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "string",
           },
         },
+      ],
+      "name": "SideNavigationWrapper",
+    },
+    {
+      "methods": [
         {
-          "description": "Returns the expandable row toggle button.",
-          "name": "findExpandToggle",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
           "parameters": [
             {
-              "description": "1-based index of the row.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "rowIndex",
-              "typeName": "number",
+              "name": "selector",
+              "typeName": "string",
             },
           ],
           "returnType": {
@@ -108515,50 +111835,117 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findFilterSlot",
-          "parameters": [],
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findFooterSlot",
-          "parameters": [],
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
         {
-          "description": "Alias for findHeaderSlot method for compatibility with previous versions",
-          "name": "findHeaderRegion",
-          "parameters": [],
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findHeaderSlot",
-          "parameters": [],
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
         {
-          "description": "Returns items loader of the specific item (matched by item's track ID).",
-          "name": "findItemsLoaderByItemId",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
           "parameters": [
             {
-              "description": "the (expandable) item ID provided with \`trackBy\` property.
-
-Note: when used with collection-hooks the \`trackBy\` is set automatically from \`expandableRows.getId\`.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "itemId",
+              "name": "className",
               "typeName": "string",
             },
           ],
@@ -108568,7 +111955,38 @@ Note: when used with collection-hooks the \`trackBy\` is set automatically from
           },
         },
         {
-          "name": "findLoadingText",
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "name": "findDivider",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -108576,63 +111994,68 @@ Note: when used with collection-hooks the \`trackBy\` is set automatically from
           },
         },
         {
-          "name": "findPagination",
+          "name": "findExpandableLinkGroup",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "PaginationWrapper",
+            "name": "ExpandableSectionWrapper",
           },
         },
         {
-          "name": "findPropertyFilter",
+          "name": "findInfo",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "PropertyFilterWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "description": "Returns items loader of the root table level.",
-          "name": "findRootItemsLoader",
-          "parameters": [],
+          "name": "findItemByIndex",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "SideNavigationItemWrapper",
           },
         },
         {
-          "name": "findRows",
+          "name": "findItems",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "MultiElementWrapper",
             "typeArguments": [
               {
-                "name": "ElementWrapper",
+                "name": "SideNavigationItemWrapper",
               },
             ],
           },
         },
         {
-          "description": "Returns a row selection area for a given index.",
-          "name": "findRowSelectionArea",
-          "parameters": [
-            {
-              "description": "1-based index of the row selection area to return.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "rowIndex",
-              "typeName": "number",
-            },
-          ],
+          "name": "findLink",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
         {
-          "name": "findSelectAllTrigger",
+          "name": "findSection",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ExpandableSectionWrapper",
+          },
+        },
+        {
+          "name": "findSectionGroup",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -108640,24 +112063,19 @@ Note: when used with collection-hooks the \`trackBy\` is set automatically from
           },
         },
         {
-          "name": "findSelectedRows",
+          "name": "findSectionGroupTitle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findTextFilter",
+          "name": "findSectionTitle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "TextFilterWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
@@ -108702,7 +112120,7 @@ Note: when used with collection-hooks the \`trackBy\` is set automatically from
           },
         },
       ],
-      "name": "TableWrapper",
+      "name": "SideNavigationItemWrapper",
     },
     {
       "methods": [
@@ -108725,14 +112143,6 @@ Note: when used with collection-hooks the \`trackBy\` is set automatically from
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findActiveLink",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -108885,61 +112295,13 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findHeader",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findHeaderLink",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findItemByIndex",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "index",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "SideNavigationItemWrapper",
-          },
-        },
-        {
-          "name": "findItemsControl",
+          "name": "findNativeInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findLinkByHref",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "href",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -108982,7 +112344,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "SideNavigationWrapper",
+      "name": "SliderWrapper",
     },
     {
       "methods": [
@@ -109157,96 +112519,219 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findDivider",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.getElement",
+          },
+          "name": "getElement",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "string",
           },
         },
         {
-          "name": "findExpandableLinkGroup",
-          "parameters": [],
+          "inheritedFrom": {
+            "name": "AbstractWrapper.matches",
+          },
+          "name": "matches",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ExpandableSectionWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findInfo",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.toSelector",
+          },
+          "name": "toSelector",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "string",
           },
         },
+      ],
+      "name": "SpaceBetweenWrapper",
+    },
+    {
+      "methods": [
         {
-          "name": "findItemByIndex",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.find",
+          },
+          "name": "find",
           "parameters": [
             {
               "flags": {
                 "isOptional": false,
               },
-              "name": "index",
-              "typeName": "number",
+              "name": "selector",
+              "typeName": "string",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "SideNavigationItemWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findItems",
-          "parameters": [],
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAll",
+          },
+          "name": "findAll",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "MultiElementWrapper",
             "typeArguments": [
               {
-                "name": "SideNavigationItemWrapper",
+                "name": "ElementWrapper",
               },
             ],
           },
         },
         {
-          "name": "findLink",
-          "parameters": [],
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllByClassName",
+          },
+          "name": "findAllByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findSection",
-          "parameters": [],
+          "description": "Returns a multi-element wrapper that matches the specified component type with the specified CSS selector.
+If no CSS selector is specified, returns a multi-element wrapper that matches the specified component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAllComponents",
+          },
+          "name": "findAllComponents",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "ComponentWrapperClass<Wrapper>",
+            },
+            {
+              "description": "CSS Selector",
+              "flags": {
+                "isOptional": true,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ExpandableSectionWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "Wrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findSectionGroup",
-          "parameters": [],
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findAny",
+          },
+          "name": "findAny",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selectors",
+              "typeName": "Array<string>",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
         {
-          "name": "findSectionGroupTitle",
-          "parameters": [],
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findByClassName",
+          },
+          "name": "findByClassName",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "className",
+              "typeName": "string",
+            },
+          ],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
         {
-          "name": "findSectionTitle",
-          "parameters": [],
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
+
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
+          "inheritedFrom": {
+            "name": "AbstractWrapper.findComponent",
+          },
+          "name": "findComponent",
+          "parameters": [
+            {
+              "description": "CSS selector",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "selector",
+              "typeName": "string",
+            },
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "Wrapper",
           },
         },
         {
@@ -109291,7 +112776,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "SideNavigationItemWrapper",
+      "name": "SpinnerWrapper",
     },
     {
       "methods": [
@@ -109465,14 +112950,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
-        {
-          "name": "findNativeInput",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -109515,7 +112992,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "SliderWrapper",
+      "name": "StatusIndicatorWrapper",
     },
     {
       "methods": [
@@ -109689,6 +113166,20 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
+        {
+          "description": "Finds all step items",
+          "name": "findItems",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "StepWrapper",
+              },
+            ],
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -109731,7 +113222,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "SpaceBetweenWrapper",
+      "name": "StepsWrapper",
     },
     {
       "methods": [
@@ -109905,6 +113396,24 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
+        {
+          "description": "Finds the details of a step",
+          "name": "findDetails",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds the header of a step",
+          "name": "findHeader",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -109947,7 +113456,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "SpinnerWrapper",
+      "name": "StepWrapper",
     },
     {
       "methods": [
@@ -109970,6 +113479,77 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
+        {
+          "description": "Finds the tab action by using the tab id",
+          "name": "findActionByTabId",
+          "parameters": [
+            {
+              "description": "ID of the clickable element to return",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds the tab action by using the tab index",
+          "name": "findActionByTabIndex",
+          "parameters": [
+            {
+              "description": "1-based index of the clickable element to return",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findActions",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds the currently active tab and returns the clickable element from its tab label.",
+          "name": "findActiveTab",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds the tab action for the active tab",
+          "name": "findActiveTabAction",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds the dismissible button for the active tab",
+          "name": "findActiveTabDismissibleButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -110112,13 +113692,135 @@ Note: This function returns the specified component's wrapper even if the specif
               "flags": {
                 "isOptional": false,
               },
-              "name": "ComponentClass",
-              "typeName": "WrapperClass<Wrapper>",
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "Wrapper",
+          },
+        },
+        {
+          "description": "Finds the dismissible button by using the tab id",
+          "name": "findDismissibleButtonByTabId",
+          "parameters": [
+            {
+              "description": "ID of the clickable element to return",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "description": "Finds the dismissible button by using the tab index.",
+          "name": "findDismissibleButtonByTabIndex",
+          "parameters": [
+            {
+              "description": "1-based index of the clickable element to return",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "description": "Finds the currently focused tab, which might not be active if disabled with a reason.",
+          "name": "findFocusedTab",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds the currently displayed tab content and returns it.",
+          "name": "findTabContent",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds the tab header container at the given position (1-based) and returns the element.",
+          "name": "findTabHeaderContentByIndex",
+          "parameters": [
+            {
+              "description": "1-based index of the clickable element to return",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds the tab with the given ID and returns the clickable element from its tab label.",
+          "name": "findTabLinkById",
+          "parameters": [
+            {
+              "description": "ID of the clickable element to return",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "TabWrapper",
+          },
+        },
+        {
+          "description": "Finds the tab at the given position (1-based) and returns the clickable element from its tab label.",
+          "name": "findTabLinkByIndex",
+          "parameters": [
+            {
+              "description": "1-based index of the clickable element to return",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "Wrapper",
+            "name": "TabWrapper",
+          },
+        },
+        {
+          "description": "Finds all tab headers and returns the clickable elements from their labels.",
+          "name": "findTabLinks",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
         {
@@ -110163,7 +113865,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "StatusIndicatorWrapper",
+      "name": "TabsWrapper",
     },
     {
       "methods": [
@@ -110338,17 +114040,11 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Finds all step items",
-          "name": "findItems",
+          "name": "findDisabledReason",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "StepWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
@@ -110393,7 +114089,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "StepsWrapper",
+      "name": "TabWrapper",
     },
     {
       "methods": [
@@ -110417,76 +114113,27 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Finds the tab action by using the tab id",
-          "name": "findActionByTabId",
-          "parameters": [
-            {
-              "description": "ID of the clickable element to return",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "id",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Finds the tab action by using the tab index",
-          "name": "findActionByTabIndex",
-          "parameters": [
-            {
-              "description": "1-based index of the clickable element to return",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "index",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
+          "inheritedFrom": {
+            "name": "AttributeEditorWrapper.findAddButton",
           },
-        },
-        {
-          "name": "findActions",
+          "name": "findAddButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
-          "description": "Finds the currently active tab and returns the clickable element from its tab label.",
-          "name": "findActiveTab",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
+          "inheritedFrom": {
+            "name": "AttributeEditorWrapper.findAdditionalInfo",
           },
-        },
-        {
-          "description": "Finds the tab action for the active tab",
-          "name": "findActiveTabAction",
+          "name": "findAdditionalInfo",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
-        {
-          "description": "Finds the dismissible button for the active tab",
-          "name": "findActiveTabDismissibleButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -110639,44 +114286,10 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Finds the dismissible button by using the tab id",
-          "name": "findDismissibleButtonByTabId",
-          "parameters": [
-            {
-              "description": "ID of the clickable element to return",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "id",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
-        {
-          "description": "Finds the dismissible button by using the tab index.",
-          "name": "findDismissibleButtonByTabIndex",
-          "parameters": [
-            {
-              "description": "1-based index of the clickable element to return",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "index",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
+          "inheritedFrom": {
+            "name": "AttributeEditorWrapper.findEmptySlot",
           },
-        },
-        {
-          "description": "Finds the currently focused tab, which might not be active if disabled with a reason.",
-          "name": "findFocusedTab",
+          "name": "findEmptySlot",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -110684,8 +114297,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Finds the currently displayed tab content and returns it.",
-          "name": "findTabContent",
+          "name": "findLoadingText",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -110693,69 +114305,35 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Finds the tab header container at the given position (1-based) and returns the element.",
-          "name": "findTabHeaderContentByIndex",
-          "parameters": [
-            {
-              "description": "1-based index of the clickable element to return",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "index",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Finds the tab with the given ID and returns the clickable element from its tab label.",
-          "name": "findTabLinkById",
-          "parameters": [
-            {
-              "description": "ID of the clickable element to return",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "id",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "TabWrapper",
-          },
-        },
-        {
-          "description": "Finds the tab at the given position (1-based) and returns the clickable element from its tab label.",
-          "name": "findTabLinkByIndex",
+          "description": "Returns a row for a given index.",
+          "name": "findRow",
           "parameters": [
             {
-              "description": "1-based index of the clickable element to return",
+              "description": "1-based row index",
               "flags": {
                 "isOptional": false,
               },
-              "name": "index",
+              "name": "row",
               "typeName": "number",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "TabWrapper",
+            "name": "TagEditorRowWrapper",
           },
         },
         {
-          "description": "Finds all tab headers and returns the clickable elements from their labels.",
-          "name": "findTabLinks",
+          "description": "Returns all rows.
+
+To find a specific row use the \`findRow(n)\` function as chaining \`findRows().get(n)\` can return unexpected results.",
+          "name": "findRows",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "MultiElementWrapper",
             "typeArguments": [
               {
-                "name": "ElementWrapper",
+                "name": "TagEditorRowWrapper",
               },
             ],
           },
@@ -110802,7 +114380,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TabsWrapper",
+      "name": "TagEditorWrapper",
     },
     {
       "methods": [
@@ -110973,15 +114551,75 @@ Note: This function returns the specified component's wrapper even if the specif
           ],
           "returnType": {
             "isNullable": false,
-            "name": "Wrapper",
+            "name": "Wrapper",
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AttributeEditorRowWrapper.findCustomAction",
+          },
+          "name": "findCustomAction",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Returns a field for a given index",
+          "inheritedFrom": {
+            "name": "AttributeEditorRowWrapper.findField",
+          },
+          "name": "findField",
+          "parameters": [
+            {
+              "description": "1-based column index",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "column",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "FormFieldWrapper",
+          },
+        },
+        {
+          "description": "Returns all fields. Fields are supplied in the \`definition\` property of the component.",
+          "inheritedFrom": {
+            "name": "AttributeEditorRowWrapper.findFields",
+          },
+          "name": "findFields",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "FormFieldWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "inheritedFrom": {
+            "name": "AttributeEditorRowWrapper.findRemoveButton",
+          },
+          "name": "findRemoveButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
           },
         },
         {
-          "name": "findDisabledReason",
+          "name": "findUndoButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "LinkWrapper",
           },
         },
         {
@@ -111026,7 +114664,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TabWrapper",
+      "name": "TagEditorRowWrapper",
     },
     {
       "methods": [
@@ -111049,28 +114687,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
-        {
-          "inheritedFrom": {
-            "name": "AttributeEditorWrapper.findAddButton",
-          },
-          "name": "findAddButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AttributeEditorWrapper.findAdditionalInfo",
-          },
-          "name": "findAdditionalInfo",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -111222,59 +114838,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
-        {
-          "inheritedFrom": {
-            "name": "AttributeEditorWrapper.findEmptySlot",
-          },
-          "name": "findEmptySlot",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findLoadingText",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Returns a row for a given index.",
-          "name": "findRow",
-          "parameters": [
-            {
-              "description": "1-based row index",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "row",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "TagEditorRowWrapper",
-          },
-        },
-        {
-          "description": "Returns all rows.
-
-To find a specific row use the \`findRow(n)\` function as chaining \`findRows().get(n)\` can return unexpected results.",
-          "name": "findRows",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "TagEditorRowWrapper",
-              },
-            ],
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -111317,7 +114880,7 @@ To find a specific row use the \`findRow(n)\` function as chaining \`findRows().
           },
         },
       ],
-      "name": "TagEditorWrapper",
+      "name": "TextContentWrapper",
     },
     {
       "methods": [
@@ -111492,73 +115055,13 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "AttributeEditorRowWrapper.findCustomAction",
-          },
-          "name": "findCustomAction",
+          "name": "findNativeTextarea",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
-        {
-          "description": "Returns a field for a given index",
-          "inheritedFrom": {
-            "name": "AttributeEditorRowWrapper.findField",
-          },
-          "name": "findField",
-          "parameters": [
-            {
-              "description": "1-based column index",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "column",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "FormFieldWrapper",
-          },
-        },
-        {
-          "description": "Returns all fields. Fields are supplied in the \`definition\` property of the component.",
-          "inheritedFrom": {
-            "name": "AttributeEditorRowWrapper.findFields",
-          },
-          "name": "findFields",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "FormFieldWrapper",
-              },
-            ],
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "AttributeEditorRowWrapper.findRemoveButton",
-          },
-          "name": "findRemoveButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
-        {
-          "name": "findUndoButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "LinkWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -111601,7 +115104,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TagEditorRowWrapper",
+      "name": "TextareaWrapper",
     },
     {
       "methods": [
@@ -111775,6 +115278,51 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "Wrapper",
           },
         },
+        {
+          "name": "findInputByValue",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "value",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findItemByValue",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "value",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "TileWrapper",
+          },
+        },
+        {
+          "name": "findItems",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "TileWrapper",
+              },
+            ],
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -111817,7 +115365,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TextContentWrapper",
+      "name": "TilesWrapper",
     },
     {
       "methods": [
@@ -111992,7 +115540,31 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findNativeTextarea",
+          "name": "findDescription",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findImage",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findLabel",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findNativeInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -112041,7 +115613,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TextareaWrapper",
+      "name": "TileWrapper",
     },
     {
       "methods": [
@@ -112206,58 +115778,24 @@ Note: This function returns the specified component's wrapper even if the specif
               "flags": {
                 "isOptional": false,
               },
-              "name": "ComponentClass",
-              "typeName": "WrapperClass<Wrapper>",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "Wrapper",
-          },
-        },
-        {
-          "name": "findInputByValue",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "value",
-              "typeName": "string",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findItemByValue",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "value",
-              "typeName": "string",
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "TileWrapper",
+            "name": "Wrapper",
           },
         },
         {
-          "name": "findItems",
+          "inheritedFrom": {
+            "name": "BaseInputWrapper.findNativeInput",
+          },
+          "name": "findNativeInput",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "TileWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
@@ -112302,7 +115840,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TilesWrapper",
+      "name": "TimeInputWrapper",
     },
     {
       "methods": [
@@ -112477,31 +116015,39 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findDescription",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findImage",
-          "parameters": [],
+          "description": "Returns a token from the group for a given index.",
+          "name": "findToken",
+          "parameters": [
+            {
+              "description": "1-based index of the token to return.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "tokenIndex",
+              "typeName": "number",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "TokenWrapper",
           },
         },
         {
-          "name": "findLabel",
+          "name": "findTokens",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "TokenWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findNativeInput",
+          "description": "Returns the token toggle button.",
+          "name": "findTokenToggle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -112550,7 +116096,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TileWrapper",
+      "name": "TokenGroupWrapper",
     },
     {
       "methods": [
@@ -112725,16 +116271,90 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "inheritedFrom": {
-            "name": "BaseInputWrapper.findNativeInput",
+          "name": "findIdentityLink",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
           },
-          "name": "findNativeInput",
+        },
+        {
+          "name": "findLogo",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findOverflowMenu",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "OverflowMenu",
+          },
+        },
+        {
+          "name": "findOverflowMenuButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "name": "findSearch",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findSearchButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findTitle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findUtilities",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "TopNavigationUtilityWrapper",
+              },
+            ],
+          },
+        },
+        {
+          "name": "findUtility",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "index",
+              "typeName": "number",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "TopNavigationUtilityWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.getElement",
@@ -112777,7 +116397,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TimeInputWrapper",
+      "name": "TopNavigationWrapper",
     },
     {
       "methods": [
@@ -112901,6 +116521,14 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findButtonLinkType",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "LinkWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -112952,43 +116580,19 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Returns a token from the group for a given index.",
-          "name": "findToken",
-          "parameters": [
-            {
-              "description": "1-based index of the token to return.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "tokenIndex",
-              "typeName": "number",
-            },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "TokenWrapper",
-          },
-        },
-        {
-          "name": "findTokens",
+          "name": "findMenuDropdownType",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "TokenWrapper",
-              },
-            ],
+            "name": "TopNavigationMenuDropdownWrapper",
           },
         },
         {
-          "description": "Returns the token toggle button.",
-          "name": "findTokenToggle",
+          "name": "findPrimaryButtonType",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
@@ -113033,7 +116637,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TokenGroupWrapper",
+      "name": "TopNavigationUtilityWrapper",
     },
     {
       "methods": [
@@ -113208,7 +116812,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findIdentityLink",
+          "name": "findDescription",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -113216,7 +116820,11 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findLogo",
+          "description": "Finds the disabled reason tooltip for a dropdown item. Returns null if no disabled item with \`disabledReason\` is highlighted.",
+          "inheritedFrom": {
+            "name": "ButtonDropdownWrapper.findDisabledReason",
+          },
+          "name": "findDisabledReason",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -113224,15 +116832,87 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findOverflowMenu",
+          "description": "Finds an expandable category in the open dropdown by category id. Returns null if there is no open dropdown.
+
+This utility does not open the dropdown. To find dropdown items, call \`openDropdown()\` first.",
+          "inheritedFrom": {
+            "name": "ButtonDropdownWrapper.findExpandableCategoryById",
+          },
+          "name": "findExpandableCategoryById",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds the highlighted item in the open dropdown. Returns null if there is no open dropdown.
+
+This utility does not open the dropdown. To find dropdown items, call \`openDropdown()\` first.",
+          "inheritedFrom": {
+            "name": "ButtonDropdownWrapper.findHighlightedItem",
+          },
+          "name": "findHighlightedItem",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds an item in the open dropdown by item id. Returns null if there is no open dropdown.
+
+This utility does not open the dropdown. To find dropdown items, call \`openDropdown()\` first.",
+          "inheritedFrom": {
+            "name": "ButtonDropdownWrapper.findItemById",
+          },
+          "name": "findItemById",
+          "parameters": [
+            {
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+          ],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "description": "Finds all the items in the open dropdown. Returns empty array if there is no open dropdown.
+
+This utility does not open the dropdown. To find dropdown items, call \`openDropdown()\` first.",
+          "inheritedFrom": {
+            "name": "ButtonDropdownWrapper.findItems",
+          },
+          "name": "findItems",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "OverflowMenu",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findOverflowMenuButton",
+          "inheritedFrom": {
+            "name": "ButtonDropdownWrapper.findMainAction",
+          },
+          "name": "findMainAction",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -113240,7 +116920,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findSearch",
+          "name": "findNativeButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -113248,7 +116928,10 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findSearchButton",
+          "inheritedFrom": {
+            "name": "ButtonDropdownWrapper.findOpenDropdown",
+          },
+          "name": "findOpenDropdown",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -113264,32 +116947,14 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findUtilities",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "TopNavigationUtilityWrapper",
-              },
-            ],
+          "inheritedFrom": {
+            "name": "ButtonDropdownWrapper.findTriggerButton",
           },
-        },
-        {
-          "name": "findUtility",
-          "parameters": [
-            {
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "index",
-              "typeName": "number",
-            },
-          ],
+          "name": "findTriggerButton",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "TopNavigationUtilityWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
@@ -113334,7 +116999,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TopNavigationWrapper",
+      "name": "TopNavigationMenuDropdownWrapper",
     },
     {
       "methods": [
@@ -113458,14 +117123,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findButtonLinkType",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "LinkWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findByClassName",
@@ -113517,19 +117174,54 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findMenuDropdownType",
-          "parameters": [],
+          "description": "Finds a visible tree view item by its ID.",
+          "name": "findItemById",
+          "parameters": [
+            {
+              "description": "of the item to find",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "id",
+              "typeName": "string",
+            },
+            {
+              "defaultValue": "{}",
+              "description": "* expanded (optiona, boolean) - Use it to find the visible expanded or collapsed item.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expanded?: boolean | undefined; }",
+            },
+          ],
           "returnType": {
-            "isNullable": false,
-            "name": "TopNavigationMenuDropdownWrapper",
+            "isNullable": true,
+            "name": "TreeViewItemWrapper",
           },
         },
         {
-          "name": "findPrimaryButtonType",
-          "parameters": [],
+          "description": "Finds all visible tree view items.",
+          "name": "findItems",
+          "parameters": [
+            {
+              "defaultValue": "{}",
+              "description": "* expanded (optional, boolean) - Use it to find all visible expanded or collapsed items.",
+              "flags": {
+                "isOptional": false,
+              },
+              "name": "options",
+              "typeName": "{ expanded?: boolean | undefined; }",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "TreeViewItemWrapper",
+              },
+            ],
           },
         },
         {
@@ -113574,7 +117266,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TopNavigationUtilityWrapper",
+      "name": "TreeViewWrapper",
     },
     {
       "methods": [
@@ -113597,6 +117289,15 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
+        {
+          "description": "Finds the actions slot of the tree view item.",
+          "name": "findActions",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -113718,146 +117419,90 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
-
-Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
-          "inheritedFrom": {
-            "name": "AbstractWrapper.findComponent",
-          },
-          "name": "findComponent",
+          "description": "Finds a visible child item by its ID.",
+          "name": "findChildItemById",
           "parameters": [
             {
-              "description": "CSS selector",
+              "description": "of the item to find",
               "flags": {
                 "isOptional": false,
               },
-              "name": "selector",
+              "name": "id",
               "typeName": "string",
             },
             {
-              "description": "Component's wrapper class",
+              "defaultValue": "{}",
+              "description": "* expanded (optional, boolean) - Use it to find the visible expanded or collapsed child item.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "ComponentClass",
-              "typeName": "WrapperClass<Wrapper>",
+              "name": "options",
+              "typeName": "{ expanded?: boolean | undefined; }",
             },
           ],
           "returnType": {
-            "isNullable": false,
-            "name": "Wrapper",
-          },
-        },
-        {
-          "name": "findDescription",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Finds the disabled reason tooltip for a dropdown item. Returns null if no disabled item with \`disabledReason\` is highlighted.",
-          "inheritedFrom": {
-            "name": "ButtonDropdownWrapper.findDisabledReason",
-          },
-          "name": "findDisabledReason",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
+            "isNullable": true,
+            "name": "TreeViewItemWrapper",
           },
         },
         {
-          "description": "Finds an expandable category in the open dropdown by category id. Returns null if there is no open dropdown.
-
-This utility does not open the dropdown. To find dropdown items, call \`openDropdown()\` first.",
-          "inheritedFrom": {
-            "name": "ButtonDropdownWrapper.findExpandableCategoryById",
-          },
-          "name": "findExpandableCategoryById",
+          "description": "Finds all visible child items of the tree view item.",
+          "name": "findChildItems",
           "parameters": [
             {
+              "defaultValue": "{}",
+              "description": "* expanded (optional, boolean) - Use it to find all visible expanded or collapsed child items.",
               "flags": {
                 "isOptional": false,
               },
-              "name": "id",
-              "typeName": "string",
+              "name": "options",
+              "typeName": "{ expanded?: boolean | undefined; }",
             },
           ],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Finds the highlighted item in the open dropdown. Returns null if there is no open dropdown.
-
-This utility does not open the dropdown. To find dropdown items, call \`openDropdown()\` first.",
-          "inheritedFrom": {
-            "name": "ButtonDropdownWrapper.findHighlightedItem",
-          },
-          "name": "findHighlightedItem",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "TreeViewItemWrapper",
+              },
+            ],
           },
         },
         {
-          "description": "Finds an item in the open dropdown by item id. Returns null if there is no open dropdown.
+          "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
-This utility does not open the dropdown. To find dropdown items, call \`openDropdown()\` first.",
+Note: This function returns the specified component's wrapper even if the specified selector points to a different component type.",
           "inheritedFrom": {
-            "name": "ButtonDropdownWrapper.findItemById",
+            "name": "AbstractWrapper.findComponent",
           },
-          "name": "findItemById",
+          "name": "findComponent",
           "parameters": [
             {
+              "description": "CSS selector",
               "flags": {
                 "isOptional": false,
               },
-              "name": "id",
+              "name": "selector",
               "typeName": "string",
             },
-          ],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "description": "Finds all the items in the open dropdown. Returns empty array if there is no open dropdown.
-
-This utility does not open the dropdown. To find dropdown items, call \`openDropdown()\` first.",
-          "inheritedFrom": {
-            "name": "ButtonDropdownWrapper.findItems",
-          },
-          "name": "findItems",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "ElementWrapper",
+            {
+              "description": "Component's wrapper class",
+              "flags": {
+                "isOptional": false,
               },
-            ],
-          },
-        },
-        {
-          "inheritedFrom": {
-            "name": "ButtonDropdownWrapper.findMainAction",
-          },
-          "name": "findMainAction",
-          "parameters": [],
+              "name": "ComponentClass",
+              "typeName": "WrapperClass<Wrapper>",
+            },
+          ],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "Wrapper",
           },
         },
         {
-          "name": "findNativeButton",
+          "description": "Finds the content slot of the tree view item.",
+          "name": "findContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -113865,10 +117510,8 @@ This utility does not open the dropdown. To find dropdown items, call \`openDrop
           },
         },
         {
-          "inheritedFrom": {
-            "name": "ButtonDropdownWrapper.findOpenDropdown",
-          },
-          "name": "findOpenDropdown",
+          "description": "Finds the icon slot of the tree view item.",
+          "name": "findIcon",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -113876,7 +117519,8 @@ This utility does not open the dropdown. To find dropdown items, call \`openDrop
           },
         },
         {
-          "name": "findTitle",
+          "description": "Finds the expand toggle of the tree view item.",
+          "name": "findItemToggle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -113884,14 +117528,12 @@ This utility does not open the dropdown. To find dropdown items, call \`openDrop
           },
         },
         {
-          "inheritedFrom": {
-            "name": "ButtonDropdownWrapper.findTriggerButton",
-          },
-          "name": "findTriggerButton",
+          "description": "Finds the secondary content slot of the tree view item.",
+          "name": "findSecondaryContent",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ButtonWrapper",
+            "name": "ElementWrapper",
           },
         },
         {
@@ -113936,7 +117578,7 @@ This utility does not open the dropdown. To find dropdown items, call \`openDrop
           },
         },
       ],
-      "name": "TopNavigationMenuDropdownWrapper",
+      "name": "TreeViewItemWrapper",
     },
     {
       "methods": [
@@ -114079,6 +117721,22 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
+        {
+          "name": "findCompletionScreenDescription",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
+        {
+          "name": "findCompletionScreenTitle",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ElementWrapper",
+          },
+        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -114111,52 +117769,51 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Finds a visible tree view item by its ID.",
-          "name": "findItemById",
-          "parameters": [
-            {
-              "description": "of the item to find",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "id",
-              "typeName": "string",
-            },
-            {
-              "defaultValue": "{}",
-              "description": "* expanded (optiona, boolean) - Use it to find the visible expanded or collapsed item.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expanded?: boolean | undefined; }",
-            },
-          ],
+          "name": "findDismissButton",
+          "parameters": [],
           "returnType": {
-            "isNullable": true,
-            "name": "TreeViewItemWrapper",
+            "isNullable": false,
+            "name": "ButtonWrapper",
           },
         },
         {
-          "description": "Finds all visible tree view items.",
-          "name": "findItems",
-          "parameters": [
-            {
-              "defaultValue": "{}",
-              "description": "* expanded (optional, boolean) - Use it to find all visible expanded or collapsed items.",
-              "flags": {
-                "isOptional": false,
+          "name": "findDownloadLink",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "LinkWrapper",
+          },
+        },
+        {
+          "name": "findFeedbackLink",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "LinkWrapper",
+          },
+        },
+        {
+          "name": "findTaskList",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "TutorialTaskWrapper",
               },
-              "name": "options",
-              "typeName": "{ expanded?: boolean | undefined; }",
-            },
-          ],
+            ],
+          },
+        },
+        {
+          "name": "findTutorials",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
             "name": "MultiElementWrapper",
             "typeArguments": [
               {
-                "name": "TreeViewItemWrapper",
+                "name": "TutorialItemWrapper",
               },
             ],
           },
@@ -114203,7 +117860,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TreeViewWrapper",
+      "name": "TutorialPanelWrapper",
     },
     {
       "methods": [
@@ -114226,15 +117883,6 @@ Note: This function returns the specified component's wrapper even if the specif
             "name": "ElementWrapper",
           },
         },
-        {
-          "description": "Finds the actions slot of the tree view item.",
-          "name": "findActions",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "inheritedFrom": {
             "name": "AbstractWrapper.findAll",
@@ -114356,54 +118004,19 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
           },
         },
         {
-          "description": "Finds a visible child item by its ID.",
-          "name": "findChildItemById",
-          "parameters": [
-            {
-              "description": "of the item to find",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "id",
-              "typeName": "string",
-            },
-            {
-              "defaultValue": "{}",
-              "description": "* expanded (optional, boolean) - Use it to find the visible expanded or collapsed child item.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expanded?: boolean | undefined; }",
-            },
-          ],
+          "name": "findCollapseButton",
+          "parameters": [],
           "returnType": {
-            "isNullable": true,
-            "name": "TreeViewItemWrapper",
+            "isNullable": false,
+            "name": "ButtonWrapper",
           },
         },
         {
-          "description": "Finds all visible child items of the tree view item.",
-          "name": "findChildItems",
-          "parameters": [
-            {
-              "defaultValue": "{}",
-              "description": "* expanded (optional, boolean) - Use it to find all visible expanded or collapsed child items.",
-              "flags": {
-                "isOptional": false,
-              },
-              "name": "options",
-              "typeName": "{ expanded?: boolean | undefined; }",
-            },
-          ],
+          "name": "findCompleted",
+          "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "TreeViewItemWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
@@ -114438,8 +118051,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Finds the content slot of the tree view item.",
-          "name": "findContent",
+          "name": "findDescription",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -114447,26 +118059,39 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "description": "Finds the icon slot of the tree view item.",
-          "name": "findIcon",
+          "name": "findExpandButton",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "ButtonWrapper",
           },
         },
         {
-          "description": "Finds the expand toggle of the tree view item.",
-          "name": "findItemToggle",
+          "name": "findLearnMoreLink",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "ElementWrapper",
+            "name": "LinkWrapper",
           },
         },
         {
-          "description": "Finds the secondary content slot of the tree view item.",
-          "name": "findSecondaryContent",
+          "name": "findPrerequisitesAlert",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "AlertWrapper",
+          },
+        },
+        {
+          "name": "findStartButton",
+          "parameters": [],
+          "returnType": {
+            "isNullable": false,
+            "name": "ButtonWrapper",
+          },
+        },
+        {
+          "name": "findTitle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
@@ -114515,7 +118140,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TreeViewItemWrapper",
+      "name": "TutorialItemWrapper",
     },
     {
       "methods": [
@@ -114658,22 +118283,6 @@ If no CSS selector is specified, returns a multi-element wrapper that matches th
             "name": "ElementWrapper",
           },
         },
-        {
-          "name": "findCompletionScreenDescription",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
-        {
-          "name": "findCompletionScreenTitle",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ElementWrapper",
-          },
-        },
         {
           "description": "Returns a wrapper that matches the specified component type with the specified CSS selector.
 
@@ -114706,53 +118315,32 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
         {
-          "name": "findDismissButton",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "ButtonWrapper",
-          },
-        },
-        {
-          "name": "findDownloadLink",
-          "parameters": [],
-          "returnType": {
-            "isNullable": false,
-            "name": "LinkWrapper",
-          },
-        },
-        {
-          "name": "findFeedbackLink",
+          "name": "findSteps",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "LinkWrapper",
+            "name": "MultiElementWrapper",
+            "typeArguments": [
+              {
+                "name": "ElementWrapper",
+              },
+            ],
           },
         },
         {
-          "name": "findTaskList",
+          "name": "findStepsTitle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "TutorialTaskWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
-          "name": "findTutorials",
+          "name": "findTitle",
           "parameters": [],
           "returnType": {
             "isNullable": false,
-            "name": "MultiElementWrapper",
-            "typeArguments": [
-              {
-                "name": "TutorialItemWrapper",
-              },
-            ],
+            "name": "ElementWrapper",
           },
         },
         {
@@ -114797,7 +118385,7 @@ Note: This function returns the specified component's wrapper even if the specif
           },
         },
       ],
-      "name": "TutorialPanelWrapper",
+      "name": "TutorialTaskWrapper",
     },
     {
       "methods": [

From 3038c293d20dd2a036841b547be039ea6fef74f9 Mon Sep 17 00:00:00 2001
From: Andrei Zhaleznichenka <zhalea@amazon.de>
Date: Fri, 12 Sep 2025 11:51:44 +0200
Subject: [PATCH 16/32] chore: Fixes mixed charts popover behaviour for React
 18 (#3851)

---
 .../__integ__/announcements.test.ts           |  8 +--
 src/mixed-line-bar-chart/__integ__/common.ts  |  2 +
 .../__tests__/keyboard-navigation.test.tsx    | 63 +++++++++++++------
 src/mixed-line-bar-chart/chart-container.tsx  | 28 ++++-----
 src/mixed-line-bar-chart/hooks/use-popover.ts | 23 +++++--
 5 files changed, 79 insertions(+), 45 deletions(-)

diff --git a/src/mixed-line-bar-chart/__integ__/announcements.test.ts b/src/mixed-line-bar-chart/__integ__/announcements.test.ts
index c50dc41802..56912da0bf 100644
--- a/src/mixed-line-bar-chart/__integ__/announcements.test.ts
+++ b/src/mixed-line-bar-chart/__integ__/announcements.test.ts
@@ -37,9 +37,9 @@ describe('Popover content is announced as plain text on hover', () => {
     test(
       'with expandable sub-items',
       setupTest(`#/light/mixed-line-bar-chart/drilldown?useLinks=${useLinks}&expandableSubItems=true`, async page => {
-        const coordinateIndex = 3;
         const wrapper = createWrapper().findMixedLineBarChart();
-        const barGroup = wrapper.findBarGroups().get(coordinateIndex).toSelector();
+        const barGroup = wrapper.findBarGroups().get(3).toSelector();
+        const nextBarGroup = wrapper.findBarGroups().get(4).toSelector();
         const getLabel = () => page.getElementAttribute(barGroup, 'aria-label');
         await page.hoverElement(barGroup);
         await page.waitForAssertion(async () => {
@@ -56,11 +56,11 @@ describe('Popover content is announced as plain text on hover', () => {
         await page.click(
           wrapper.findDetailPopover().findContent().findExpandableSection().findExpandButton().toSelector()
         );
-        // Pin and dismiss the poover,
+        // Pin and dismiss the popover,
         // then hover over a different item and come back to hover the initial one.
         await page.clickBarGroup(barGroup);
         await page.click(wrapper.findDetailPopover().findDismissButton().toSelector());
-        await page.hoverElement(wrapper.findBarGroups().get(4).toSelector());
+        await page.hoverElement(nextBarGroup);
         await page.hoverElement(barGroup);
         await page.waitForAssertion(async () => {
           const label = await getLabel();
diff --git a/src/mixed-line-bar-chart/__integ__/common.ts b/src/mixed-line-bar-chart/__integ__/common.ts
index ce0389378a..74a568f868 100644
--- a/src/mixed-line-bar-chart/__integ__/common.ts
+++ b/src/mixed-line-bar-chart/__integ__/common.ts
@@ -29,6 +29,8 @@ export class MixedChartPage extends BasePageObject {
       // If a popover was pinned, we need to unpin it before pinning another one.
       if (this.currentIndex) {
         await this.click(this.wrapper.findDetailPopover().findDismissButton().toSelector());
+        // Wait for popover dismiss reopen delay.
+        await this.pause(50);
       }
       this.currentIndex = index;
       await this.clickBarGroup(barGroup);
diff --git a/src/mixed-line-bar-chart/__tests__/keyboard-navigation.test.tsx b/src/mixed-line-bar-chart/__tests__/keyboard-navigation.test.tsx
index 0f1711537a..4bb57146f4 100644
--- a/src/mixed-line-bar-chart/__tests__/keyboard-navigation.test.tsx
+++ b/src/mixed-line-bar-chart/__tests__/keyboard-navigation.test.tsx
@@ -4,14 +4,33 @@
 import React from 'react';
 import { render } from '@testing-library/react';
 
+import { createWrapper } from '@cloudscape-design/test-utils-core/dom';
+
 import { KeyCode } from '../../../lib/components/internal/keycode';
 import MixedLineBarChart from '../../../lib/components/mixed-line-bar-chart';
-import { MixedLineBarChartWrapper } from '../../../lib/components/test-utils/dom';
 import { barSeries, lineSeries3, thresholdSeries } from './common';
 
 describe('Keyboard navigation', () => {
-  test('opens popover for each series', () => {
-    const { container } = render(
+  function getChart() {
+    return createWrapper().findMixedLineBarChart()!;
+  }
+  function expectValues(a: Array<number>) {
+    for (let i = 0; i < a.length; i++) {
+      const value = a[i];
+      expect(getChart().findDetailPopover()!.findSeries()![i].findValue().getElement()).toHaveTextContent(
+        value.toString()
+      );
+    }
+  }
+  function focusApplication() {
+    getChart().findApplication()!.focus();
+  }
+  function goToNextDataPoint() {
+    getChart().findApplication()!.keydown(KeyCode.right);
+  }
+
+  test('opens popover for each series (mixed)', () => {
+    render(
       <MixedLineBarChart
         height={250}
         xDomain={['Potatoes', 'Chocolate', 'Apples', 'Oranges']}
@@ -20,23 +39,7 @@ describe('Keyboard navigation', () => {
         series={[barSeries, lineSeries3, thresholdSeries]}
       />
     );
-
-    const chart = new MixedLineBarChartWrapper(container);
-    const application = chart.findApplication()!;
-
-    const expectValues = (a: Array<number>) => {
-      for (let i = 0; i < a.length; i++) {
-        const value = a[i];
-        expect(chart.findDetailPopover()!.findSeries()![i].findValue().getElement()).toHaveTextContent(
-          value.toString()
-        );
-      }
-    };
-
-    const goToNextDataPoint = () => application.keydown(KeyCode.right);
-
-    application.focus(); // Focusing the application opens the popover
-
+    focusApplication(); // Focusing the application opens the popover
     expectValues([77, 7, 8]);
     goToNextDataPoint();
     expectValues([546, 5, 8]);
@@ -45,4 +48,24 @@ describe('Keyboard navigation', () => {
     goToNextDataPoint();
     expectValues([47, 7, 8]);
   });
+
+  test('opens popover for each series (line)', () => {
+    render(
+      <MixedLineBarChart
+        height={250}
+        xDomain={['Potatoes', 'Chocolate', 'Apples', 'Oranges']}
+        yDomain={[0, 10]}
+        xScaleType="categorical"
+        series={[lineSeries3]}
+      />
+    );
+    focusApplication(); // Focusing the application opens the popover
+    expectValues([7]);
+    goToNextDataPoint();
+    expectValues([5]);
+    goToNextDataPoint();
+    expectValues([9]);
+    goToNextDataPoint();
+    expectValues([7]);
+  });
 });
diff --git a/src/mixed-line-bar-chart/chart-container.tsx b/src/mixed-line-bar-chart/chart-container.tsx
index d928c1aa71..a20396139c 100644
--- a/src/mixed-line-bar-chart/chart-container.tsx
+++ b/src/mixed-line-bar-chart/chart-container.tsx
@@ -1,6 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
 import { getIsRtl, useMergeRefs } from '@cloudscape-design/component-toolkit/internal';
 
@@ -223,7 +223,7 @@ export default function ChartContainer<T extends ChartDataTypes>({
   const scaledSeries = makeScaledSeries(visibleSeries, xAxisProps.scale, yAxisProps.scale);
   const barGroups: ScaledBarGroup<T>[] = makeScaledBarGroups(visibleSeries, xAxisProps.scale, plotWidth, plotHeight, y);
 
-  const { isPopoverOpen, isPopoverPinned, showPopover, pinPopover, dismissPopover } = usePopover();
+  const { isPopoverOpen, isPopoverPinned, showPopover, pinPopover, hidePopover, dismissPopover } = usePopover();
 
   // Allows to add a delay between popover is dismissed and handlers are enabled to prevent immediate popover reopening.
   const [isHandlersDisabled, setHandlersDisabled] = useState(false);
@@ -251,13 +251,11 @@ export default function ChartContainer<T extends ChartDataTypes>({
       setHighlightedPoint(point);
       if (point) {
         highlightSeries(point.series);
-        setVerticalMarkerX({
-          scaledX: point.x,
-          label: point.datum?.x ?? null,
-        });
+        setVerticalMarkerX({ scaledX: point.x, label: point.datum?.x ?? null });
+        showPopover();
       }
     },
-    [setHighlightedGroupIndex, setHighlightedPoint, highlightSeries]
+    [setHighlightedGroupIndex, setHighlightedPoint, highlightSeries, showPopover]
   );
 
   const clearAllHighlights = useCallback(() => {
@@ -273,8 +271,9 @@ export default function ChartContainer<T extends ChartDataTypes>({
         clearAllHighlights();
       }
       setVerticalMarkerX(marker);
+      showPopover();
     },
-    [clearAllHighlights]
+    [clearAllHighlights, showPopover]
   );
 
   // Highlight all points and bars at a given X index in a mixed line and bar chart
@@ -283,14 +282,15 @@ export default function ChartContainer<T extends ChartDataTypes>({
       highlightSeries(null);
       setHighlightedPoint(null);
       setHighlightedGroupIndex(groupIndex);
+      showPopover();
     },
-    [highlightSeries, setHighlightedPoint, setHighlightedGroupIndex]
+    [highlightSeries, setHighlightedPoint, setHighlightedGroupIndex, showPopover]
   );
 
   const clearHighlightedSeries = useCallback(() => {
     clearAllHighlights();
-    dismissPopover();
-  }, [dismissPopover, clearAllHighlights]);
+    hidePopover();
+  }, [hidePopover, clearAllHighlights]);
 
   const { isGroupNavigation, ...handlers } = useNavigation({
     series,
@@ -349,12 +349,6 @@ export default function ChartContainer<T extends ChartDataTypes>({
     return () => document.removeEventListener('keydown', onKeyDown);
   }, [dismissPopover]);
 
-  useLayoutEffect(() => {
-    if (highlightedX !== null || highlightedPoint !== null) {
-      showPopover();
-    }
-  }, [highlightedX, highlightedPoint, showPopover]);
-
   const onPopoverDismiss = (outsideClick?: boolean) => {
     dismissPopover();
 
diff --git a/src/mixed-line-bar-chart/hooks/use-popover.ts b/src/mixed-line-bar-chart/hooks/use-popover.ts
index 954c1dec88..ebb92c39fa 100644
--- a/src/mixed-line-bar-chart/hooks/use-popover.ts
+++ b/src/mixed-line-bar-chart/hooks/use-popover.ts
@@ -1,16 +1,31 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { useCallback, useState } from 'react';
+
+import { useCallback, useRef, useState } from 'react';
+
+// The delay prevents re-opening popover immediately upon dismissing,
+// so that the popover actually closes. It can be reopened with the next
+// hover or focus event that occurs after the delay.
+const REOPEN_DELAY_MS = 50;
 
 export function usePopover() {
+  const dismissedTimeRef = useRef(Date.now() - REOPEN_DELAY_MS);
   const [state, setState] = useState<'open' | 'closed' | 'pinned'>('closed');
 
   const isPopoverOpen = state !== 'closed';
   const isPopoverPinned = state === 'pinned';
 
-  const showPopover = useCallback(() => setState('open'), []);
+  const showPopover = useCallback(() => {
+    if (Date.now() - dismissedTimeRef.current > REOPEN_DELAY_MS) {
+      setState('open');
+    }
+  }, []);
   const pinPopover = useCallback(() => setState('pinned'), []);
-  const dismissPopover = useCallback(() => setState('closed'), []);
+  const hidePopover = useCallback(() => setState('closed'), []);
+  const dismissPopover = useCallback(() => {
+    setState('closed');
+    dismissedTimeRef.current = Date.now();
+  }, []);
 
-  return { isPopoverOpen, isPopoverPinned, showPopover, pinPopover, dismissPopover };
+  return { isPopoverOpen, isPopoverPinned, showPopover, pinPopover, hidePopover, dismissPopover };
 }

From 3672dfd1f806a1ae198ada2cb0b96c02723b9a46 Mon Sep 17 00:00:00 2001
From: Andrei Zhaleznichenka <zhalea@amazon.de>
Date: Mon, 15 Sep 2025 13:30:23 +0200
Subject: [PATCH 17/32] fix: Fixes mixed chart popover reopen in tests (#3862)

---
 .../__tests__/mixed-chart.test.tsx            | 34 +++++++++++++++++++
 src/mixed-line-bar-chart/hooks/use-popover.ts |  8 +++--
 2 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/src/mixed-line-bar-chart/__tests__/mixed-chart.test.tsx b/src/mixed-line-bar-chart/__tests__/mixed-chart.test.tsx
index 34238aed0c..ee4b698526 100644
--- a/src/mixed-line-bar-chart/__tests__/mixed-chart.test.tsx
+++ b/src/mixed-line-bar-chart/__tests__/mixed-chart.test.tsx
@@ -981,6 +981,40 @@ describe('Details popover', () => {
     expect(wrapper.findByClassName(styles.exiting)).not.toBeNull();
   });
 
+  test('can be hidden with Escape and then reopened', async () => {
+    const { wrapper } = renderMixedChart(<MixedLineBarChart {...mixedChartProps} />);
+    const isPopoverVisible = () => !wrapper.findByClassName(styles.exiting);
+    const isPopoverPinned = () => !!wrapper.findDetailPopover()!.findDismissButton();
+
+    wrapper.findApplication()!.focus();
+    expect(isPopoverVisible()).toBe(true);
+
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+    expect(isPopoverVisible()).toBe(false);
+
+    wrapper.findApplication()!.keydown(KeyCode.right);
+    expect(isPopoverVisible()).toBe(true);
+
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+    expect(isPopoverVisible()).toBe(false);
+
+    wrapper.findApplication()!.keydown(KeyCode.enter);
+    expect(isPopoverVisible()).toBe(true);
+    expect(isPopoverPinned()).toBe(true);
+
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+    expect(isPopoverVisible()).toBe(false);
+
+    // The popover is not re-opened within 50ms from un-pinning.
+    wrapper.findApplication()!.keydown(KeyCode.right);
+    expect(isPopoverVisible()).toBe(false);
+
+    await new Promise(resolve => setTimeout(resolve, 50 + 1));
+
+    wrapper.findApplication()!.keydown(KeyCode.right);
+    expect(isPopoverVisible()).toBe(true);
+  });
+
   test('delegates focus back to chart when unpinned in a non-grouped chart', async () => {
     const { wrapper } = renderMixedChart(<MixedLineBarChart {...lineChartProps} />);
 
diff --git a/src/mixed-line-bar-chart/hooks/use-popover.ts b/src/mixed-line-bar-chart/hooks/use-popover.ts
index ebb92c39fa..1914999d2e 100644
--- a/src/mixed-line-bar-chart/hooks/use-popover.ts
+++ b/src/mixed-line-bar-chart/hooks/use-popover.ts
@@ -23,8 +23,12 @@ export function usePopover() {
   const pinPopover = useCallback(() => setState('pinned'), []);
   const hidePopover = useCallback(() => setState('closed'), []);
   const dismissPopover = useCallback(() => {
-    setState('closed');
-    dismissedTimeRef.current = Date.now();
+    setState(prev => {
+      if (prev === 'pinned') {
+        dismissedTimeRef.current = Date.now();
+      }
+      return 'closed';
+    });
   }, []);
 
   return { isPopoverOpen, isPopoverPinned, showPopover, pinPopover, hidePopover, dismissPopover };

From 5af655dd35f94564a660861280cc48ea57a1d704 Mon Sep 17 00:00:00 2001
From: Gethin Webster <gethinw@amazon.de>
Date: Mon, 15 Sep 2025 14:30:15 +0200
Subject: [PATCH 18/32] feat: Native attributes for status indicator (#3843)

---
 .../__snapshots__/documenter.test.ts.snap     | 22 ++++++++++++++++++
 .../__tests__/status-indicator.test.tsx       | 14 +++++++++++
 src/status-indicator/internal.tsx             | 23 +++++++++++++++++--
 3 files changed, 57 insertions(+), 2 deletions(-)

diff --git a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
index 36f3f9d024..a3ec0990cb 100644
--- a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
+++ b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
@@ -22585,6 +22585,28 @@ use the \`id\` attribute, consider setting it on a parent element instead.",
       "optional": true,
       "type": "string",
     },
+    {
+      "description": "Attributes to add to the native element.
+Some attributes will be automatically combined with internal attribute values:
+- \`className\` will be appended.
+- Event handlers will be chained, unless the default is prevented.
+
+We do not support using this attribute to apply custom styling.",
+      "inlineType": {
+        "name": "Omit<React.HTMLAttributes<HTMLElement>, "children"> & Record<\`data-\${string}\`, string>",
+        "type": "union",
+        "values": [
+          "Omit<React.HTMLAttributes<HTMLElement>, "children">",
+          "Record<\`data-\${string}\`, string>",
+        ],
+      },
+      "name": "nativeAttributes",
+      "optional": true,
+      "systemTags": [
+        "core",
+      ],
+      "type": "Omit<React.HTMLAttributes<HTMLElement>, "children"> & Record<\`data-\${string}\`, string>",
+    },
     {
       "defaultValue": "'success'",
       "description": "Specifies the status type.",
diff --git a/src/status-indicator/__tests__/status-indicator.test.tsx b/src/status-indicator/__tests__/status-indicator.test.tsx
index 8211af1be0..c5fd14c2bd 100644
--- a/src/status-indicator/__tests__/status-indicator.test.tsx
+++ b/src/status-indicator/__tests__/status-indicator.test.tsx
@@ -34,4 +34,18 @@ describe('StatusIndicator', () => {
     const statusIndicatorWrapper = createWrapper(container.parentElement!).findStatusIndicator()!;
     expect(statusIndicatorWrapper.findByClassName(styles.icon)!.getElement()).toHaveAttribute('aria-label', ariaLabel);
   });
+
+  describe('native attributes', () => {
+    it('adds native attributes', () => {
+      const { container } = render(<StatusIndicator type="info" nativeAttributes={{ 'data-testid': 'my-test-id' }} />);
+      expect(container.querySelectorAll('[data-testid="my-test-id"]')).toHaveLength(1);
+    });
+    it('concatenates class names', () => {
+      const { container } = render(
+        <StatusIndicator type="info" nativeAttributes={{ className: 'additional-class' }} />
+      );
+      expect(container.firstChild).toHaveClass(styles.root);
+      expect(container.firstChild).toHaveClass('additional-class');
+    });
+  });
 });
diff --git a/src/status-indicator/internal.tsx b/src/status-indicator/internal.tsx
index 790b49afd8..a0ee492c07 100644
--- a/src/status-indicator/internal.tsx
+++ b/src/status-indicator/internal.tsx
@@ -8,6 +8,10 @@ import InternalIcon from '../icon/internal';
 import { BaseComponentProps, getBaseProps } from '../internal/base-component';
 import { InternalBaseComponentProps } from '../internal/hooks/use-base-component';
 import { SomeRequired } from '../internal/types';
+/**
+ * @awsuiSystem core
+ */
+import WithNativeAttributes, { NativeAttributes } from '../internal/utils/with-native-attributes';
 import InternalSpinner from '../spinner/internal';
 
 import styles from './styles.css.js';
@@ -46,6 +50,17 @@ export interface StatusIndicatorProps extends BaseComponentProps {
    * and truncates it with an ellipsis.
    */
   wrapText?: boolean;
+  /**
+   * Attributes to add to the native element.
+   * Some attributes will be automatically combined with internal attribute values:
+   * - `className` will be appended.
+   * - Event handlers will be chained, unless the default is prevented.
+   *
+   * We do not support using this attribute to apply custom styling.
+   *
+   * @awsuiSystem core
+   */
+  nativeAttributes?: NativeAttributes<React.HTMLAttributes<HTMLElement>>;
 }
 
 export interface InternalStatusIndicatorProps
@@ -80,6 +95,7 @@ export default function StatusIndicator({
   iconAriaLabel,
   colorOverride,
   wrapText = true,
+  nativeAttributes,
   __animate = false,
   __internalRootRef,
   __size = 'normal',
@@ -88,8 +104,11 @@ export default function StatusIndicator({
 }: InternalStatusIndicatorProps) {
   const baseProps = getBaseProps(rest);
   return (
-    <span
+    <WithNativeAttributes
       {...baseProps}
+      tag="span"
+      componentName="StatusIndicator"
+      nativeAttributes={nativeAttributes}
       className={clsx(
         styles.root,
         styles[`status-${type}`],
@@ -118,6 +137,6 @@ export default function StatusIndicator({
         </span>
         {children}
       </span>
-    </span>
+    </WithNativeAttributes>
   );
 }

From 3074fe19b8977417e78b55b13cbe2e92699fcc55 Mon Sep 17 00:00:00 2001
From: Gethin Webster <gethinw@amazon.de>
Date: Mon, 15 Sep 2025 17:35:59 +0200
Subject: [PATCH 19/32] revert: "feat: Native attributes for status indicator
 (#3843)" (#3866)

---
 .../__snapshots__/documenter.test.ts.snap     | 22 ------------------
 .../__tests__/status-indicator.test.tsx       | 14 -----------
 src/status-indicator/internal.tsx             | 23 ++-----------------
 3 files changed, 2 insertions(+), 57 deletions(-)

diff --git a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
index a3ec0990cb..36f3f9d024 100644
--- a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
+++ b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
@@ -22585,28 +22585,6 @@ use the \`id\` attribute, consider setting it on a parent element instead.",
       "optional": true,
       "type": "string",
     },
-    {
-      "description": "Attributes to add to the native element.
-Some attributes will be automatically combined with internal attribute values:
-- \`className\` will be appended.
-- Event handlers will be chained, unless the default is prevented.
-
-We do not support using this attribute to apply custom styling.",
-      "inlineType": {
-        "name": "Omit<React.HTMLAttributes<HTMLElement>, "children"> & Record<\`data-\${string}\`, string>",
-        "type": "union",
-        "values": [
-          "Omit<React.HTMLAttributes<HTMLElement>, "children">",
-          "Record<\`data-\${string}\`, string>",
-        ],
-      },
-      "name": "nativeAttributes",
-      "optional": true,
-      "systemTags": [
-        "core",
-      ],
-      "type": "Omit<React.HTMLAttributes<HTMLElement>, "children"> & Record<\`data-\${string}\`, string>",
-    },
     {
       "defaultValue": "'success'",
       "description": "Specifies the status type.",
diff --git a/src/status-indicator/__tests__/status-indicator.test.tsx b/src/status-indicator/__tests__/status-indicator.test.tsx
index c5fd14c2bd..8211af1be0 100644
--- a/src/status-indicator/__tests__/status-indicator.test.tsx
+++ b/src/status-indicator/__tests__/status-indicator.test.tsx
@@ -34,18 +34,4 @@ describe('StatusIndicator', () => {
     const statusIndicatorWrapper = createWrapper(container.parentElement!).findStatusIndicator()!;
     expect(statusIndicatorWrapper.findByClassName(styles.icon)!.getElement()).toHaveAttribute('aria-label', ariaLabel);
   });
-
-  describe('native attributes', () => {
-    it('adds native attributes', () => {
-      const { container } = render(<StatusIndicator type="info" nativeAttributes={{ 'data-testid': 'my-test-id' }} />);
-      expect(container.querySelectorAll('[data-testid="my-test-id"]')).toHaveLength(1);
-    });
-    it('concatenates class names', () => {
-      const { container } = render(
-        <StatusIndicator type="info" nativeAttributes={{ className: 'additional-class' }} />
-      );
-      expect(container.firstChild).toHaveClass(styles.root);
-      expect(container.firstChild).toHaveClass('additional-class');
-    });
-  });
 });
diff --git a/src/status-indicator/internal.tsx b/src/status-indicator/internal.tsx
index a0ee492c07..790b49afd8 100644
--- a/src/status-indicator/internal.tsx
+++ b/src/status-indicator/internal.tsx
@@ -8,10 +8,6 @@ import InternalIcon from '../icon/internal';
 import { BaseComponentProps, getBaseProps } from '../internal/base-component';
 import { InternalBaseComponentProps } from '../internal/hooks/use-base-component';
 import { SomeRequired } from '../internal/types';
-/**
- * @awsuiSystem core
- */
-import WithNativeAttributes, { NativeAttributes } from '../internal/utils/with-native-attributes';
 import InternalSpinner from '../spinner/internal';
 
 import styles from './styles.css.js';
@@ -50,17 +46,6 @@ export interface StatusIndicatorProps extends BaseComponentProps {
    * and truncates it with an ellipsis.
    */
   wrapText?: boolean;
-  /**
-   * Attributes to add to the native element.
-   * Some attributes will be automatically combined with internal attribute values:
-   * - `className` will be appended.
-   * - Event handlers will be chained, unless the default is prevented.
-   *
-   * We do not support using this attribute to apply custom styling.
-   *
-   * @awsuiSystem core
-   */
-  nativeAttributes?: NativeAttributes<React.HTMLAttributes<HTMLElement>>;
 }
 
 export interface InternalStatusIndicatorProps
@@ -95,7 +80,6 @@ export default function StatusIndicator({
   iconAriaLabel,
   colorOverride,
   wrapText = true,
-  nativeAttributes,
   __animate = false,
   __internalRootRef,
   __size = 'normal',
@@ -104,11 +88,8 @@ export default function StatusIndicator({
 }: InternalStatusIndicatorProps) {
   const baseProps = getBaseProps(rest);
   return (
-    <WithNativeAttributes
+    <span
       {...baseProps}
-      tag="span"
-      componentName="StatusIndicator"
-      nativeAttributes={nativeAttributes}
       className={clsx(
         styles.root,
         styles[`status-${type}`],
@@ -137,6 +118,6 @@ export default function StatusIndicator({
         </span>
         {children}
       </span>
-    </WithNativeAttributes>
+    </span>
   );
 }

From ca35e1a5fa80dce48d837694827af36a96119a18 Mon Sep 17 00:00:00 2001
From: Gethin Webster <gethinw@amazon.de>
Date: Tue, 16 Sep 2025 11:49:28 +0200
Subject: [PATCH 20/32] feat: Add native attributes support for link, toggle,
 toggle button (#3838)

---
 .../__snapshots__/documenter.test.ts.snap     | 66 ++++++++++++-------
 src/link/__tests__/index.test.tsx             | 18 +++++
 src/link/interfaces.ts                        | 16 +++++
 src/link/internal.tsx                         | 16 +++--
 .../__tests__/toggle-button.test.tsx          | 19 ++++++
 src/toggle-button/index.tsx                   |  2 +
 src/toggle-button/interfaces.ts               |  2 +-
 src/toggle-button/internal.tsx                |  2 +
 src/toggle/__tests__/toggle.test.tsx          | 14 ++++
 src/toggle/interfaces.ts                      | 16 +++++
 src/toggle/internal.tsx                       |  7 +-
 11 files changed, 150 insertions(+), 28 deletions(-)

diff --git a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
index 36f3f9d024..3362f26e9e 100644
--- a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
+++ b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
@@ -15356,6 +15356,28 @@ use the \`id\` attribute, consider setting it on a parent element instead.",
       "optional": true,
       "type": "string",
     },
+    {
+      "description": "Attributes to add to the native element.
+Some attributes will be automatically combined with internal attribute values:
+- \`className\` will be appended.
+- Event handlers will be chained, unless the default is prevented.
+
+We do not support using this attribute to apply custom styling.",
+      "inlineType": {
+        "name": "Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "children"> & Record<\`data-\${string}\`, string>",
+        "type": "union",
+        "values": [
+          "Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "children">",
+          "Record<\`data-\${string}\`, string>",
+        ],
+      },
+      "name": "nativeAttributes",
+      "optional": true,
+      "systemTags": [
+        "core",
+      ],
+      "type": "Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "children"> & Record<\`data-\${string}\`, string>",
+    },
     {
       "description": "Adds a \`rel\` attribute to the link. If the \`rel\` property is provided, it overrides the default behaviour.
 By default, the component sets the \`rel\` attribute to "noopener noreferrer" when \`external\` is \`true\` or \`target\` is \`"_blank"\`.",
@@ -25424,6 +25446,28 @@ use the \`id\` attribute, consider setting it on a parent element instead.",
       "optional": true,
       "type": "string",
     },
+    {
+      "description": "Attributes to add to the native \`input\` element.
+Some attributes will be automatically combined with internal attribute values:
+- \`className\` will be appended.
+- Event handlers will be chained, unless the default is prevented.
+
+We do not support using this attribute to apply custom styling.",
+      "inlineType": {
+        "name": "Omit<React.InputHTMLAttributes<HTMLInputElement>, "children"> & Record<\`data-\${string}\`, string>",
+        "type": "union",
+        "values": [
+          "Omit<React.InputHTMLAttributes<HTMLInputElement>, "children">",
+          "Record<\`data-\${string}\`, string>",
+        ],
+      },
+      "name": "nativeInputAttributes",
+      "optional": true,
+      "systemTags": [
+        "core",
+      ],
+      "type": "Omit<React.InputHTMLAttributes<HTMLInputElement>, "children"> & Record<\`data-\${string}\`, string>",
+    },
     {
       "description": "Specifies if the control is read-only, which prevents the
 user from modifying the value. Should be used only inside forms.
@@ -25894,28 +25938,6 @@ It prevents users from clicking the button, but it can still be focused.",
       "optional": true,
       "type": "string",
     },
-    {
-      "description": "Attributes to add to the native \`a\` element (when \`href\` is provided).
-Some attributes will be automatically combined with internal attribute values:
-- \`className\` will be appended.
-- Event handlers will be chained, unless the default is prevented.
-
-We do not support using this attribute to apply custom styling.",
-      "inlineType": {
-        "name": "Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "children"> & Record<\`data-\${string}\`, string>",
-        "type": "union",
-        "values": [
-          "Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "children">",
-          "Record<\`data-\${string}\`, string>",
-        ],
-      },
-      "name": "nativeAnchorAttributes",
-      "optional": true,
-      "systemTags": [
-        "core",
-      ],
-      "type": "Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "children"> & Record<\`data-\${string}\`, string>",
-    },
     {
       "description": "Attributes to add to the native \`button\` element.
 Some attributes will be automatically combined with internal attribute values:
diff --git a/src/link/__tests__/index.test.tsx b/src/link/__tests__/index.test.tsx
index 4b92151b9b..f033577bf9 100644
--- a/src/link/__tests__/index.test.tsx
+++ b/src/link/__tests__/index.test.tsx
@@ -424,3 +424,21 @@ describe('Style API', () => {
     expect(getComputedStyle(link).getPropertyValue(customCssProps.styleFocusRingBorderWidth)).toBe('4px');
   });
 });
+
+describe('native attributes', () => {
+  it('adds native attributes', () => {
+    const { container } = render(<Link href="#" nativeAttributes={{ 'data-testid': 'my-test-id' }} />);
+    expect(container.querySelectorAll('[data-testid="my-test-id"]')).toHaveLength(1);
+    expect(container.querySelectorAll('a[data-testid="my-test-id"]')).toHaveLength(1);
+  });
+  it('adds native attributes (button link)', () => {
+    const { container } = render(<Link nativeAttributes={{ 'data-testid': 'my-test-id' }} />);
+    expect(container.querySelectorAll('[data-testid="my-test-id"]')).toHaveLength(1);
+    expect(container.querySelectorAll('a[data-testid="my-test-id"]')).toHaveLength(1);
+  });
+  it('concatenates class names', () => {
+    const { container } = render(<Link href="#" nativeAttributes={{ className: 'additional-class' }} />);
+    expect(container.firstChild).toHaveClass(styles.link);
+    expect(container.firstChild).toHaveClass('additional-class');
+  });
+});
diff --git a/src/link/interfaces.ts b/src/link/interfaces.ts
index 70808b8cf7..256f837337 100644
--- a/src/link/interfaces.ts
+++ b/src/link/interfaces.ts
@@ -9,6 +9,10 @@ import {
   ClickDetail as _ClickDetail,
   NonCancelableEventHandler,
 } from '../internal/events';
+/**
+ * @awsuiSystem core
+ */
+import { NativeAttributes } from '../internal/utils/with-native-attributes';
 
 export interface LinkProps extends BaseComponentProps {
   /**
@@ -111,6 +115,18 @@ export interface LinkProps extends BaseComponentProps {
    * @awsuiSystem core
    */
   style?: LinkProps.Style;
+
+  /**
+   * Attributes to add to the native element.
+   * Some attributes will be automatically combined with internal attribute values:
+   * - `className` will be appended.
+   * - Event handlers will be chained, unless the default is prevented.
+   *
+   * We do not support using this attribute to apply custom styling.
+   *
+   * @awsuiSystem core
+   */
+  nativeAttributes?: NativeAttributes<React.AnchorHTMLAttributes<HTMLAnchorElement>>;
 }
 
 export namespace LinkProps {
diff --git a/src/link/internal.tsx b/src/link/internal.tsx
index d36764b3f4..ccf9f38804 100644
--- a/src/link/internal.tsx
+++ b/src/link/internal.tsx
@@ -25,6 +25,7 @@ import { InternalBaseComponentProps } from '../internal/hooks/use-base-component
 import { useVisualRefresh } from '../internal/hooks/use-visual-mode';
 import { KeyCode } from '../internal/keycode';
 import { checkSafeUrl } from '../internal/utils/check-safe-url';
+import WithNativeAttributes from '../internal/utils/with-native-attributes';
 import { LinkProps } from './interfaces';
 import { getLinkStyles } from './style';
 
@@ -50,6 +51,7 @@ const InternalLink = React.forwardRef(
       onFollow,
       onClick,
       children,
+      nativeAttributes,
       __internalRootRef,
       style,
       ...props
@@ -210,21 +212,27 @@ const InternalLink = React.forwardRef(
 
     if (isButton) {
       return (
-        <a
+        <WithNativeAttributes
           {...sharedProps}
+          tag="a"
+          componentName="Link"
+          nativeAttributes={nativeAttributes}
           role="button"
           tabIndex={tabIndex}
           onKeyDown={handleButtonKeyDown}
           onClick={handleButtonClick}
         >
           {content}
-        </a>
+        </WithNativeAttributes>
       );
     }
 
     return (
-      <a
+      <WithNativeAttributes
         {...sharedProps}
+        tag="a"
+        componentName="Link"
+        nativeAttributes={nativeAttributes}
         tabIndex={tabIndex}
         target={anchorTarget}
         rel={anchorRel}
@@ -232,7 +240,7 @@ const InternalLink = React.forwardRef(
         onClick={handleLinkClick}
       >
         {content}
-      </a>
+      </WithNativeAttributes>
     );
   }
 );
diff --git a/src/toggle-button/__tests__/toggle-button.test.tsx b/src/toggle-button/__tests__/toggle-button.test.tsx
index 42e91c1b1a..41ae06994e 100644
--- a/src/toggle-button/__tests__/toggle-button.test.tsx
+++ b/src/toggle-button/__tests__/toggle-button.test.tsx
@@ -9,6 +9,8 @@ import createWrapper from '../../../lib/components/test-utils/dom';
 import ToggleButton, { ToggleButtonProps } from '../../../lib/components/toggle-button';
 import { getToggleIcon } from '../../../lib/components/toggle-button/util';
 
+import styles from '../../../lib/components/button/styles.css.js';
+
 jest.mock('@cloudscape-design/component-toolkit/internal', () => ({
   ...jest.requireActual('@cloudscape-design/component-toolkit/internal'),
   warnOnce: jest.fn(),
@@ -133,4 +135,21 @@ describe('ToggleButton Component', () => {
       expect(getToggleIcon(true, 'star')).toBe('star');
     });
   });
+
+  describe('native attributes', () => {
+    it('adds native attributes', () => {
+      const { container } = render(
+        <ToggleButton pressed={true} nativeButtonAttributes={{ 'data-testid': 'my-test-id' }} />
+      );
+      expect(container.querySelectorAll('[data-testid="my-test-id"]')).toHaveLength(1);
+      expect(container.querySelectorAll('button[data-testid="my-test-id"]')).toHaveLength(1);
+    });
+    it('concatenates class names', () => {
+      const { container } = render(
+        <ToggleButton pressed={true} nativeButtonAttributes={{ className: 'additional-class' }} />
+      );
+      expect(container.firstChild).toHaveClass(styles.button);
+      expect(container.firstChild).toHaveClass('additional-class');
+    });
+  });
 });
diff --git a/src/toggle-button/index.tsx b/src/toggle-button/index.tsx
index 645e4453d5..bdfd2bdd3d 100644
--- a/src/toggle-button/index.tsx
+++ b/src/toggle-button/index.tsx
@@ -31,6 +31,7 @@ const ToggleButton = React.forwardRef(
       ariaDescribedby,
       ariaControls,
       pressed = false,
+      nativeButtonAttributes,
       onChange,
       ...props
     }: ToggleButtonProps,
@@ -65,6 +66,7 @@ const ToggleButton = React.forwardRef(
         pressedIconUrl={pressedIconUrl}
         pressedIconSvg={pressedIconSvg}
         pressed={pressed}
+        nativeButtonAttributes={nativeButtonAttributes}
         onChange={onChange}
       >
         {children}
diff --git a/src/toggle-button/interfaces.ts b/src/toggle-button/interfaces.ts
index 417bf4dd92..485a9ca753 100644
--- a/src/toggle-button/interfaces.ts
+++ b/src/toggle-button/interfaces.ts
@@ -7,7 +7,7 @@ import { IconProps } from '../icon/interfaces';
 import { BaseComponentProps } from '../internal/base-component';
 import { NonCancelableEventHandler } from '../internal/events';
 
-export interface ToggleButtonProps extends BaseComponentProps, BaseButtonProps {
+export interface ToggleButtonProps extends BaseComponentProps, Omit<BaseButtonProps, 'nativeAnchorAttributes'> {
   /** Determines the general styling of the toggle button as follows:
    * * `normal` for secondary buttons.
    * * `icon` to display an icon only (no text).
diff --git a/src/toggle-button/internal.tsx b/src/toggle-button/internal.tsx
index 4272aae6e8..00fb7fc9a4 100644
--- a/src/toggle-button/internal.tsx
+++ b/src/toggle-button/internal.tsx
@@ -24,6 +24,7 @@ export const InternalToggleButton = React.forwardRef(
       iconUrl: defaultIconUrl,
       pressedIconUrl,
       variant,
+      nativeButtonAttributes,
       onChange,
       className,
       ...rest
@@ -60,6 +61,7 @@ export const InternalToggleButton = React.forwardRef(
         }}
         {...rest}
         ref={ref}
+        nativeButtonAttributes={nativeButtonAttributes}
       />
     );
   }
diff --git a/src/toggle/__tests__/toggle.test.tsx b/src/toggle/__tests__/toggle.test.tsx
index f6fd88acf3..62357d85ff 100644
--- a/src/toggle/__tests__/toggle.test.tsx
+++ b/src/toggle/__tests__/toggle.test.tsx
@@ -232,3 +232,17 @@ test('all style api properties', () => {
   expect(getComputedStyle(toggleHandle).getPropertyValue('background-color')).toBe('blue');
   expect(getComputedStyle(toggleLabel).getPropertyValue('color')).toBe('orange');
 });
+
+describe('native attributes', () => {
+  it('adds native attributes', () => {
+    const { container } = render(<Toggle checked={true} nativeInputAttributes={{ 'data-testid': 'my-test-id' }} />);
+    expect(container.querySelectorAll('[data-testid="my-test-id"]')).toHaveLength(1);
+    expect(container.querySelectorAll('input[data-testid="my-test-id"]')).toHaveLength(1);
+  });
+  it('concatenates class names', () => {
+    const { container } = render(<Toggle checked={true} nativeInputAttributes={{ className: 'additional-class' }} />);
+    const input = container.querySelector('input');
+    expect(input).toHaveClass(abstractSwitchStyles['native-input']);
+    expect(input).toHaveClass('additional-class');
+  });
+});
diff --git a/src/toggle/interfaces.ts b/src/toggle/interfaces.ts
index 3d748dd758..d686bd5dd1 100644
--- a/src/toggle/interfaces.ts
+++ b/src/toggle/interfaces.ts
@@ -4,6 +4,10 @@ import React from 'react';
 
 import { BaseCheckboxProps } from '../checkbox/base-checkbox';
 import { NonCancelableEventHandler } from '../internal/events';
+/**
+ * @awsuiSystem core
+ */
+import { NativeAttributes } from '../internal/utils/with-native-attributes';
 
 export interface ToggleProps extends BaseCheckboxProps {
   /**
@@ -22,6 +26,18 @@ export interface ToggleProps extends BaseCheckboxProps {
    * @awsuiSystem core
    */
   style?: ToggleProps.Style;
+
+  /**
+   * Attributes to add to the native `input` element.
+   * Some attributes will be automatically combined with internal attribute values:
+   * - `className` will be appended.
+   * - Event handlers will be chained, unless the default is prevented.
+   *
+   * We do not support using this attribute to apply custom styling.
+   *
+   * @awsuiSystem core
+   */
+  nativeInputAttributes?: NativeAttributes<React.InputHTMLAttributes<HTMLInputElement>>;
 }
 
 export namespace ToggleProps {
diff --git a/src/toggle/internal.tsx b/src/toggle/internal.tsx
index e89e1b878d..480be02bdf 100644
--- a/src/toggle/internal.tsx
+++ b/src/toggle/internal.tsx
@@ -14,6 +14,7 @@ import { useFormFieldContext } from '../internal/context/form-field-context';
 import { fireNonCancelableEvent } from '../internal/events';
 import useForwardFocus from '../internal/hooks/forward-focus';
 import { InternalBaseComponentProps } from '../internal/hooks/use-base-component';
+import WithNativeAttributes from '../internal/utils/with-native-attributes';
 import { GeneratedAnalyticsMetadataToggleComponent } from './analytics-metadata/interfaces';
 import { ToggleProps } from './interfaces';
 import { getAbstractSwitchStyles, getStyledControlStyle } from './style';
@@ -39,6 +40,7 @@ const InternalToggle = React.forwardRef<ToggleProps.Ref, InternalToggleProps>(
       onFocus,
       onBlur,
       onChange,
+      nativeInputAttributes,
       __internalRootRef,
       style,
       __injectAnalyticsComponentMetadata,
@@ -89,8 +91,11 @@ const InternalToggle = React.forwardRef<ToggleProps.Ref, InternalToggleProps>(
         ariaDescribedby={ariaDescribedby}
         ariaControls={ariaControls}
         nativeControl={nativeControlProps => (
-          <input
+          <WithNativeAttributes
             {...nativeControlProps}
+            tag="input"
+            componentName="Toggle"
+            nativeAttributes={nativeInputAttributes}
             ref={checkboxRef}
             type="checkbox"
             checked={checked}

From 82b94d188ec0ab2b34928d15363e715d6c4f165c Mon Sep 17 00:00:00 2001
From: Trevor Burnham <trevorburnham@gmail.com>
Date: Tue, 16 Sep 2025 06:07:39 -0400
Subject: [PATCH 21/32] test: Update tests for ResizeObserver polyfill removal
 (#3867)

---
 src/app-layout/__tests__/main.test.tsx          | 17 +++++++++++++++++
 .../__integ__/resizable-columns-misc.test.ts    |  8 ++++----
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/src/app-layout/__tests__/main.test.tsx b/src/app-layout/__tests__/main.test.tsx
index bd8f218fff..16f0899369 100644
--- a/src/app-layout/__tests__/main.test.tsx
+++ b/src/app-layout/__tests__/main.test.tsx
@@ -1,6 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import * as React from 'react';
+import { useLayoutEffect } from 'react';
 import { waitFor } from '@testing-library/react';
 
 import '../../__a11y__/to-validate-a11y';
@@ -11,6 +12,22 @@ import { describeEachAppLayout, renderComponent, testDrawer } from './utils';
 import mobileStyles from '../../../lib/components/app-layout/mobile-toolbar/styles.css.js';
 import sharedStyles from '../../../lib/components/app-layout/styles.css.js';
 
+jest.mock('@cloudscape-design/component-toolkit/internal', () => ({
+  ...jest.requireActual('@cloudscape-design/component-toolkit/internal'),
+  useResizeObserver: (getElement: any, onObserve: any) => {
+    useLayoutEffect(() => {
+      if (typeof getElement === 'function') {
+        const element = getElement();
+        if (element) {
+          // Extract height from inline styles for JSDOM compatibility
+          const height = parseInt(element.style.height) || 0;
+          onObserve({ borderBoxHeight: height });
+        }
+      }
+    }, [getElement, onObserve]);
+  },
+}));
+
 test('does not render mobile mode by default', () => {
   const { wrapper } = renderComponent(<AppLayout />);
   expect(wrapper.findByClassName(mobileStyles['mobile-bar'])).toBeFalsy();
diff --git a/src/table/__integ__/resizable-columns-misc.test.ts b/src/table/__integ__/resizable-columns-misc.test.ts
index 563e2d9a35..3da66b7017 100644
--- a/src/table/__integ__/resizable-columns-misc.test.ts
+++ b/src/table/__integ__/resizable-columns-misc.test.ts
@@ -89,11 +89,11 @@ test(
     await page.installObserver(wrapper.find('table').toSelector());
     await page.click('#shrink-container');
     await page.waitForJsTimers();
-    // expected 1 observation after creating observer and 1 caused by container shrink
-    await expect(page.getObservations()).resolves.toBe(2);
+    // check to ensure that we haven't triggered an infinite resize loop
+    await expect(page.getObservations()).resolves.toBeLessThanOrEqual(3);
     await page.waitForJsTimers();
-    // ensure there are no more observations added after the expected 2
-    await expect(page.getObservations()).resolves.toBe(2);
+    // check again to ensure that we haven't triggered an infinite resize loop
+    await expect(page.getObservations()).resolves.toBeLessThanOrEqual(3);
   })
 );
 

From a3281ccf75871d527b0a4680f560ec5a71bb141d Mon Sep 17 00:00:00 2001
From: Andrei Zhaleznichenka <zhalea@amazon.de>
Date: Tue, 16 Sep 2025 14:15:35 +0200
Subject: [PATCH 22/32] feat: Date formats for date range picker (#3837)

---
 ...te-format-day-picker.permutations.page.tsx |   4 +-
 ...-format-month-picker.permutations.page.tsx |   4 +-
 pages/date-range-picker/common.tsx            |  35 ++-
 .../month-calendar-permutations.page.tsx      |  26 +-
 .../date-range-picker/range-calendar.page.tsx |   9 +-
 pages/date-range-picker/with-value.page.tsx   |   3 +-
 .../year-calendar-permutations.page.tsx       |  15 +
 .../__snapshots__/documenter.test.ts.snap     |  55 +++-
 ...nge-picker-absolute-input-formats.test.tsx | 286 ++++++++++++++++++
 .../date-range-picker-absolute.test.tsx       |   4 +-
 .../__tests__/i18n-strings.ts                 |  32 +-
 src/date-range-picker/calendar/index.tsx      |  23 +-
 src/date-range-picker/calendar/interfaces.ts  |  72 +++++
 .../calendar/range-inputs.tsx                 |  61 +---
 src/date-range-picker/calendar/utils.ts       |  48 +++
 src/date-range-picker/dropdown.tsx            |  32 +-
 src/date-range-picker/index.tsx               |   4 +
 src/date-range-picker/interfaces.ts           |  92 ++++--
 .../format-date-time-with-offset.test.ts      |  24 +-
 .../date-time/format-date-time-with-offset.ts |   4 +
 20 files changed, 704 insertions(+), 129 deletions(-)
 create mode 100644 src/date-range-picker/__tests__/date-range-picker-absolute-input-formats.test.tsx
 create mode 100644 src/date-range-picker/calendar/interfaces.ts

diff --git a/pages/date-range-picker/absolute-format-day-picker.permutations.page.tsx b/pages/date-range-picker/absolute-format-day-picker.permutations.page.tsx
index 31c98a6380..b2fd31a964 100644
--- a/pages/date-range-picker/absolute-format-day-picker.permutations.page.tsx
+++ b/pages/date-range-picker/absolute-format-day-picker.permutations.page.tsx
@@ -12,14 +12,14 @@ import { isValid, placeholders } from './common';
 
 const permutations = createPermutations<DateRangePickerProps>([
   {
-    absoluteFormat: ['iso', 'long-localized'],
+    absoluteFormat: ['iso', 'slashed', 'long-localized'],
     dateOnly: [true, false],
     value: [{ type: 'absolute', startDate: '2024-12-30', endDate: '2024-12-31' }],
     isValidRange: [() => ({ valid: true })],
     relativeOptions: [[]],
   },
   {
-    absoluteFormat: ['iso', 'long-localized'],
+    absoluteFormat: ['iso', 'slashed', 'long-localized'],
     dateOnly: [true, false],
     hideTimeOffset: [true, false],
     value: [{ type: 'absolute', startDate: '2024-12-30T00:00:00+01:00', endDate: '2024-12-31T23:59:59+01:00' }],
diff --git a/pages/date-range-picker/absolute-format-month-picker.permutations.page.tsx b/pages/date-range-picker/absolute-format-month-picker.permutations.page.tsx
index 6ebec93473..b9e4e154f9 100644
--- a/pages/date-range-picker/absolute-format-month-picker.permutations.page.tsx
+++ b/pages/date-range-picker/absolute-format-month-picker.permutations.page.tsx
@@ -12,7 +12,7 @@ import { isValid, placeholders } from './common';
 
 const permutations = createPermutations<DateRangePickerProps>([
   {
-    absoluteFormat: ['iso', 'long-localized'],
+    absoluteFormat: ['iso', 'slashed', 'long-localized'],
     value: [
       {
         type: 'absolute',
@@ -24,7 +24,7 @@ const permutations = createPermutations<DateRangePickerProps>([
     relativeOptions: [[]],
   },
   {
-    absoluteFormat: ['iso', 'long-localized'],
+    absoluteFormat: ['iso', 'slashed', 'long-localized'],
     hideTimeOffset: [true, false],
     value: [
       {
diff --git a/pages/date-range-picker/common.tsx b/pages/date-range-picker/common.tsx
index 7779aefa6f..e46d2d4391 100644
--- a/pages/date-range-picker/common.tsx
+++ b/pages/date-range-picker/common.tsx
@@ -19,6 +19,7 @@ interface DateRangePickerPageSettings {
   warning?: boolean;
   rangeSelectorMode?: DateRangePickerProps.RangeSelectorMode;
   absoluteFormat?: DateRangePickerProps.AbsoluteFormat;
+  dateInputFormat?: DateRangePickerProps['dateInputFormat'];
   timeInputFormat?: DateRangePickerProps['timeInputFormat'];
   timeOffset?: number;
   hideTimeOffset?: boolean;
@@ -36,6 +37,7 @@ const defaultSettings: Required<DateRangePickerPageSettings> = {
   warning: false,
   rangeSelectorMode: 'default',
   absoluteFormat: 'iso',
+  dateInputFormat: 'iso',
   timeInputFormat: 'hh:mm:ss',
   timeOffset: 0,
   hideTimeOffset: false,
@@ -80,6 +82,7 @@ export function useDateRangePickerSettings(
   const rangeSelectorMode = urlParams.rangeSelectorMode ?? def('rangeSelectorMode');
   const absoluteFormat = urlParams.absoluteFormat ?? def('absoluteFormat');
   const timeInputFormat = urlParams.timeInputFormat ?? def('timeInputFormat');
+  const dateInputFormat = urlParams.dateInputFormat ?? def('dateInputFormat');
   const timeOffset = parseNumber(def('timeOffset'), urlParams.timeOffset);
   const hideTimeOffset = parseBoolean(def('hideTimeOffset'), urlParams.hideTimeOffset);
   const expandToViewport = parseBoolean(def('expandToViewport'), urlParams.expandToViewport);
@@ -94,6 +97,7 @@ export function useDateRangePickerSettings(
     warning,
     rangeSelectorMode,
     absoluteFormat,
+    dateInputFormat,
     timeInputFormat,
     timeOffset,
     hideTimeOffset,
@@ -197,6 +201,7 @@ export function useDateRangePickerSettings(
     warning,
     rangeSelectorMode,
     absoluteFormat,
+    dateInputFormat,
     timeInputFormat,
     timeOffset,
     hideTimeOffset,
@@ -242,6 +247,8 @@ export function Settings({
     warning,
     rangeSelectorMode,
     absoluteFormat,
+    dateInputFormat,
+    timeInputFormat,
     timeOffset,
     hideTimeOffset,
     expandToViewport,
@@ -263,7 +270,9 @@ export function Settings({
     { value: 'end-of-page' },
     { value: 'overlapping-pages' },
   ];
-  const absoluteFormatOptions = [{ value: 'iso' }, { value: 'long-localized' }];
+  const dateFormatOptions = [{ value: 'iso' }, { value: 'slashed' }, { value: 'long-localized' }];
+  const inputDateFormat = [{ value: 'iso' }, { value: 'slashed' }];
+  const timeFormatOptions = [{ value: 'hh:mm:ss' }, { value: 'hh:mm' }, { value: 'hh' }];
   return (
     <SpaceBetween size="m" direction="horizontal">
       <FormField label="Range selector mode">
@@ -286,14 +295,34 @@ export function Settings({
 
       <FormField label="Absolute format">
         <Select
-          options={absoluteFormatOptions}
-          selectedOption={absoluteFormatOptions.find(o => o.value === absoluteFormat) ?? null}
+          options={dateFormatOptions}
+          selectedOption={dateFormatOptions.find(o => o.value === absoluteFormat) ?? null}
           onChange={({ detail }) =>
             setSettings({ absoluteFormat: detail.selectedOption.value as DateRangePickerProps.AbsoluteFormat })
           }
         />
       </FormField>
 
+      <FormField label="Date input format">
+        <Select
+          options={inputDateFormat}
+          selectedOption={inputDateFormat.find(o => o.value === dateInputFormat) ?? null}
+          onChange={({ detail }) =>
+            setSettings({ dateInputFormat: detail.selectedOption.value as DateRangePickerProps.DateInputFormat })
+          }
+        />
+      </FormField>
+
+      <FormField label="Time input format">
+        <Select
+          options={timeFormatOptions}
+          selectedOption={timeFormatOptions.find(o => o.value === timeInputFormat) ?? null}
+          onChange={({ detail }) =>
+            setSettings({ timeInputFormat: detail.selectedOption.value as DateRangePickerProps.TimeInputFormat })
+          }
+        />
+      </FormField>
+
       <FormField label="Time offset">
         <Input
           type="number"
diff --git a/pages/date-range-picker/month-calendar-permutations.page.tsx b/pages/date-range-picker/month-calendar-permutations.page.tsx
index a0812e9f4e..889a2fa9cf 100644
--- a/pages/date-range-picker/month-calendar-permutations.page.tsx
+++ b/pages/date-range-picker/month-calendar-permutations.page.tsx
@@ -33,8 +33,9 @@ const permutations = createPermutations<DateRangePickerCalendarProps>([
     locale: ['en-GB'],
     startOfWeek: [1],
     onChange: [() => {}],
-    timeInputFormat: ['hh:mm:ss'] as const,
     customAbsoluteRangeControl: [undefined],
+    timeInputFormat: ['hh:mm:ss'] as const,
+    absoluteFormat: ['long-localized'] as const,
   })),
   // Disabled dates
   {
@@ -42,6 +43,8 @@ const permutations = createPermutations<DateRangePickerCalendarProps>([
     setValue: [() => {}],
     isDateEnabled: [() => false, (date: Date) => date.getDate() % 2 !== 0],
     customAbsoluteRangeControl: [undefined],
+    timeInputFormat: ['hh:mm:ss'] as const,
+    absoluteFormat: ['long-localized'] as const,
   },
   // Date-only
   {
@@ -49,12 +52,33 @@ const permutations = createPermutations<DateRangePickerCalendarProps>([
     setValue: [() => {}],
     dateOnly: [true],
     customAbsoluteRangeControl: [undefined],
+    timeInputFormat: ['hh:mm:ss'] as const,
+    absoluteFormat: ['long-localized'] as const,
   },
   // Custom control
   {
     value: [{ start: { date: '', time: '' }, end: { date: '', time: '' } }],
     setValue: [() => {}],
     customAbsoluteRangeControl: [() => 'Custom control'],
+    timeInputFormat: ['hh:mm:ss'] as const,
+    absoluteFormat: ['long-localized'] as const,
+  },
+  // Date input formats
+  {
+    value: [{ start: { date: '', time: '' }, end: { date: '', time: '' } }],
+    setValue: [() => {}],
+    customAbsoluteRangeControl: [undefined],
+    timeInputFormat: ['hh:mm:ss'] as const,
+    dateInputFormat: ['iso', 'slashed'] as const,
+    absoluteFormat: ['long-localized'] as const,
+  },
+  // Time input formats
+  {
+    value: [{ start: { date: '', time: '' }, end: { date: '', time: '' } }],
+    setValue: [() => {}],
+    customAbsoluteRangeControl: [undefined],
+    timeInputFormat: ['hh:mm', 'hh'] as const,
+    absoluteFormat: ['long-localized'] as const,
   },
 ]);
 
diff --git a/pages/date-range-picker/range-calendar.page.tsx b/pages/date-range-picker/range-calendar.page.tsx
index 25cc88be96..f4b93f1241 100644
--- a/pages/date-range-picker/range-calendar.page.tsx
+++ b/pages/date-range-picker/range-calendar.page.tsx
@@ -23,7 +23,14 @@ export default function RangeCalendarScenario() {
       <SpaceBetween direction="vertical" size="m">
         <Link id="focusable-before">Focusable element before</Link>
 
-        <RangeCalendar {...props} value={value} setValue={setValue} customAbsoluteRangeControl={undefined} />
+        <RangeCalendar
+          {...props}
+          value={value}
+          setValue={setValue}
+          customAbsoluteRangeControl={undefined}
+          timeInputFormat="hh:mm:ss"
+          absoluteFormat="slashed"
+        />
 
         <Link id="focusable-after">Focusable element after</Link>
       </SpaceBetween>
diff --git a/pages/date-range-picker/with-value.page.tsx b/pages/date-range-picker/with-value.page.tsx
index 6127a0cd8b..2a64da8cb0 100644
--- a/pages/date-range-picker/with-value.page.tsx
+++ b/pages/date-range-picker/with-value.page.tsx
@@ -33,7 +33,8 @@ export default function DatePickerScenario() {
 
         <br />
         <br />
-        <div style={{ blockSize: 500 }}>
+        {/* We give more space at the bottom so that the dropdown opens down and stays within the screenshot area. */}
+        <div style={{ blockSize: 800 }}>
           <b>
             Raw value: <Box variant="pre">{JSON.stringify(props.value, undefined, 2)}</Box>
           </b>
diff --git a/pages/date-range-picker/year-calendar-permutations.page.tsx b/pages/date-range-picker/year-calendar-permutations.page.tsx
index 93c16354bf..5568dcf765 100644
--- a/pages/date-range-picker/year-calendar-permutations.page.tsx
+++ b/pages/date-range-picker/year-calendar-permutations.page.tsx
@@ -31,6 +31,8 @@ const permutations = createPermutations<DateRangePickerCalendarProps>([
     locale: ['en-GB'],
     onChange: [() => {}],
     customAbsoluteRangeControl: [undefined],
+    timeInputFormat: ['hh:mm:ss'] as const,
+    absoluteFormat: ['long-localized'] as const,
   })),
   // Disabled dates
   {
@@ -38,12 +40,25 @@ const permutations = createPermutations<DateRangePickerCalendarProps>([
     setValue: [() => {}],
     isDateEnabled: [() => false],
     customAbsoluteRangeControl: [undefined],
+    timeInputFormat: ['hh:mm:ss'] as const,
+    absoluteFormat: ['long-localized'] as const,
   },
   // Custom control
   {
     value: [{ start: { date: '', time: '' }, end: { date: '', time: '' } }],
     setValue: [() => {}],
     customAbsoluteRangeControl: [() => 'Custom control'],
+    timeInputFormat: ['hh:mm:ss'] as const,
+    absoluteFormat: ['long-localized'] as const,
+  },
+  // Input date formats
+  {
+    value: [{ start: { date: '', time: '' }, end: { date: '', time: '' } }],
+    setValue: [() => {}],
+    customAbsoluteRangeControl: [undefined],
+    timeInputFormat: ['hh:mm:ss'] as const,
+    dateInputFormat: ['iso', 'slashed'] as const,
+    absoluteFormat: ['long-localized'] as const,
   },
 ]);
 
diff --git a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
index 3362f26e9e..5c50ed16d7 100644
--- a/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
+++ b/src/__tests__/snapshot-tests/__snapshots__/documenter.test.ts.snap
@@ -10247,13 +10247,13 @@ The event \`detail\` contains the current value of the field.",
 It can take the following values:
 * \`iso\`: ISO 8601 format, e.g.: 2024-01-30T13:32:32+01:00 (or 2024-01-30 when \`dateOnly\` is true)
 * \`long-localized\`: a more human-readable, localized format, e.g.: January 30, 2024, 13:32:32 (UTC+1) (or January 30, 2024 when \`dateOnly\` is true)
-
-Defaults to \`iso\`.",
+* \`slashed\`: similar to ISO 8601 but with '/' in place of '-'. e.g.: 2024/01/30 (or 2024/01)",
       "inlineType": {
-        "name": "DateRangePickerProps.AbsoluteFormat",
+        "name": "DateFormat",
         "type": "union",
         "values": [
           "iso",
+          "slashed",
           "long-localized",
         ],
       },
@@ -10348,6 +10348,25 @@ If provided, the date becomes focusable.",
       "optional": true,
       "type": "DateRangePickerProps.DateDisabledReasonFunction",
     },
+    {
+      "defaultValue": "'slashed'",
+      "description": "Specifies the date format to use on the date inputs in the absolute dropdown.
+
+The format of the input as it is being interacted with. It can take the following values:
+* \`iso\`: ISO 8601 format without time, e.g.: 2024-01-30 (or 2024-01)
+* \`slashed\`: similar to ISO 8601 but with '/' in place of '-'. e.g.: 2024/01/30 (or 2024/01)",
+      "inlineType": {
+        "name": "EditableDateFormat",
+        "type": "union",
+        "values": [
+          "iso",
+          "slashed",
+        ],
+      },
+      "name": "dateInputFormat",
+      "optional": true,
+      "type": "string",
+    },
     {
       "defaultValue": "false",
       "description": "Hides time inputs and changes the input format to date-only, e.g. 2021-04-06.
@@ -10570,6 +10589,21 @@ Defaults to \`false\`.",
             "optional": true,
             "type": "((unit: DateRangePickerProps.TimeUnit, value: number) => string)",
           },
+          {
+            "name": "isoDateConstraintText",
+            "optional": true,
+            "type": "string",
+          },
+          {
+            "name": "isoDateTimeConstraintText",
+            "optional": true,
+            "type": "string",
+          },
+          {
+            "name": "isoMonthConstraintText",
+            "optional": true,
+            "type": "string",
+          },
           {
             "name": "modeSelectionLabel",
             "optional": true,
@@ -10635,6 +10669,21 @@ Defaults to \`false\`.",
             "optional": true,
             "type": "((startDate: string, endDate: string) => string)",
           },
+          {
+            "name": "slashedDateConstraintText",
+            "optional": true,
+            "type": "string",
+          },
+          {
+            "name": "slashedDateTimeConstraintText",
+            "optional": true,
+            "type": "string",
+          },
+          {
+            "name": "slashedMonthConstraintText",
+            "optional": true,
+            "type": "string",
+          },
           {
             "name": "startDateLabel",
             "optional": true,
diff --git a/src/date-range-picker/__tests__/date-range-picker-absolute-input-formats.test.tsx b/src/date-range-picker/__tests__/date-range-picker-absolute-input-formats.test.tsx
new file mode 100644
index 0000000000..04e1fa3d76
--- /dev/null
+++ b/src/date-range-picker/__tests__/date-range-picker-absolute-input-formats.test.tsx
@@ -0,0 +1,286 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import * as React from 'react';
+import { render as rtlRender } from '@testing-library/react';
+
+import '../../__a11y__/to-validate-a11y';
+import DateRangePicker, { DateRangePickerProps } from '../../../lib/components/date-range-picker';
+import TestI18nProvider from '../../../lib/components/i18n/testing';
+import createWrapper from '../../../lib/components/test-utils/dom';
+import {
+  i18nMessages as i18nMessagesFallback,
+  i18nMessagesWithExtraFormatConstraints as i18nMessages,
+  i18nStrings as i18nStringsFallback,
+  i18nStringsWithExtraFormatConstraints as i18nStrings,
+} from './i18n-strings';
+
+const defaultProps: DateRangePickerProps = {
+  locale: 'en-US',
+  value: { type: 'absolute', startDate: '2020-01-01T12:13:14', endDate: '2020-01-01T12:13:14' },
+  onChange: () => {},
+  relativeOptions: [],
+  isValidRange: () => ({ valid: true }),
+};
+
+function randomItem<T>(array: readonly T[]): T {
+  return array[Math.floor(Math.random() * array.length)];
+}
+
+type RenderProps = Partial<DateRangePickerProps> & { i18nMessages?: Record<string, Record<string, string>> };
+
+function renderDateRangePicker(props: RenderProps) {
+  function Component(props: RenderProps) {
+    return (
+      <TestI18nProvider messages={props.i18nMessages ?? {}}>
+        <DateRangePicker {...defaultProps} {...props} />
+      </TestI18nProvider>
+    );
+  }
+  const { container, rerender } = rtlRender(<Component {...props} />);
+  const wrapper = createWrapper(container).findDateRangePicker()!;
+  const rerenderWrapper = (props: RenderProps) => rerender(<Component {...props} />);
+
+  wrapper.openDropdown();
+
+  const dropdown = wrapper.findDropdown()!;
+  const startDateInput = dropdown!.findStartDateInput()!;
+  const endDateInput = dropdown!.findEndDateInput()!;
+  const randomDateInput = randomItem([startDateInput, endDateInput]);
+  const startTimeInput = dropdown!.findStartTimeInput()!;
+  const endTimeInput = dropdown!.findEndTimeInput()!;
+  const randomTimeInput = randomItem([startTimeInput, endTimeInput]);
+
+  return { dropdown, randomDateInput, randomTimeInput, rerender: rerenderWrapper };
+}
+
+function randomAbsoluteFormat() {
+  return randomItem([undefined, 'iso', 'slashed', 'long-localized'] as const);
+}
+
+const isoDateProps: {
+  absoluteFormat: undefined | DateRangePickerProps.AbsoluteFormat;
+  dateInputFormat: undefined | DateRangePickerProps.DateInputFormat;
+}[] = [{ absoluteFormat: randomAbsoluteFormat(), dateInputFormat: 'iso' }];
+
+const slashedDateProps: {
+  absoluteFormat: undefined | DateRangePickerProps.AbsoluteFormat;
+  dateInputFormat: undefined | DateRangePickerProps.DateInputFormat;
+}[] = [
+  { absoluteFormat: randomAbsoluteFormat(), dateInputFormat: undefined },
+  { absoluteFormat: randomAbsoluteFormat(), dateInputFormat: 'slashed' },
+];
+
+describe('Date range picker: absolute mode input formats', () => {
+  describe('date input formats', () => {
+    test.each(isoDateProps)('accepts iso date input with props: %s', props => {
+      const { randomDateInput } = renderDateRangePicker({ ...props });
+      expect(randomDateInput.getInputValue()).toBe('2020-01-01');
+
+      randomDateInput.setInputValue('');
+      randomDateInput.setInputValue('2021/02/03');
+      expect(randomDateInput.getInputValue()).toBe('');
+
+      randomDateInput.setInputValue('2021-02-03');
+      expect(randomDateInput.getInputValue()).toBe('2021-02-03');
+    });
+
+    test.each(slashedDateProps)('accepts slashed date input with props: %s', props => {
+      const { randomDateInput } = renderDateRangePicker({ ...props });
+      expect(randomDateInput.getInputValue()).toBe('2020/01/01');
+
+      randomDateInput.setInputValue('');
+      randomDateInput.setInputValue('2021-02-03');
+      expect(randomDateInput.getInputValue()).toBe('');
+
+      randomDateInput.setInputValue('2021/02/03');
+      expect(randomDateInput.getInputValue()).toBe('2021/02/03');
+    });
+
+    test('accepts iso input with granularity "month"', () => {
+      const { randomDateInput } = renderDateRangePicker({ ...randomItem(isoDateProps), granularity: 'month' });
+      expect(randomDateInput.getInputValue()).toBe('2020-01');
+
+      randomDateInput.setInputValue('2021-02-03');
+      expect(randomDateInput.getInputValue()).toBe('2021-02');
+    });
+
+    test('accepts slashed input with granularity "month"', () => {
+      const { randomDateInput } = renderDateRangePicker({ ...randomItem(slashedDateProps), granularity: 'month' });
+      expect(randomDateInput.getInputValue()).toBe('2020/01');
+
+      randomDateInput.setInputValue('2021/02/03');
+      expect(randomDateInput.getInputValue()).toBe('2021/02');
+    });
+  });
+
+  describe('time input formats', () => {
+    test.each([undefined, 'hh:mm:ss'] as const)('accepts hh:mm:ss input with format %s', timeInputFormat => {
+      const { randomTimeInput } = renderDateRangePicker({ timeInputFormat });
+      expect(randomTimeInput.getInputValue()).toBe('12:13:14');
+
+      randomTimeInput.setInputValue('');
+      randomTimeInput.setInputValue('13:14:15');
+      expect(randomTimeInput.getInputValue()).toBe('13:14:15');
+    });
+
+    test('accepts hh:mm input with format hh:mm', () => {
+      const { randomTimeInput } = renderDateRangePicker({ timeInputFormat: 'hh:mm' });
+      expect(randomTimeInput.getInputValue()).toBe('12:13');
+
+      randomTimeInput.setInputValue('');
+      randomTimeInput.setInputValue('13:14:15');
+      expect(randomTimeInput.getInputValue()).toBe('');
+
+      randomTimeInput.setInputValue('13:14');
+      expect(randomTimeInput.getInputValue()).toBe('13:14');
+    });
+
+    test('accepts hh input with format hh', () => {
+      const { randomTimeInput } = renderDateRangePicker({ timeInputFormat: 'hh' });
+      expect(randomTimeInput.getInputValue()).toBe('12');
+
+      randomTimeInput.setInputValue('');
+      randomTimeInput.setInputValue('13:14:15');
+      expect(randomTimeInput.getInputValue()).toBe('');
+
+      randomTimeInput.setInputValue('13:14');
+      expect(randomTimeInput.getInputValue()).toBe('');
+
+      randomTimeInput.setInputValue('13');
+      expect(randomTimeInput.getInputValue()).toBe('13');
+    });
+  });
+
+  describe('inputs i18n', () => {
+    function assertInput(input: HTMLInputElement, placeholder: string, constraint: string) {
+      expect(input.placeholder).toBe(placeholder);
+      expect(input).toHaveAccessibleDescription(constraint);
+    }
+    function assertDateInput(placeholder: string, constraint: string) {
+      const dropdown = createWrapper().findDateRangePicker()!.findDropdown()!;
+      const input = Math.random() < 0.5 ? dropdown.findStartDateInput()! : dropdown.findEndDateInput()!;
+      assertInput(input.findNativeInput().getElement(), placeholder, constraint);
+    }
+    function assertTimeInput(placeholder: string, constraint: string) {
+      const dropdown = createWrapper().findDateRangePicker()!.findDropdown()!;
+      const input = Math.random() < 0.5 ? dropdown.findStartTimeInput()! : dropdown.findEndTimeInput()!;
+      assertInput(input.findNativeInput().getElement(), placeholder, constraint);
+    }
+
+    const messages = (caseOptions: { i18n: boolean; fallback: boolean }) => {
+      switch (`${caseOptions.i18n}-${caseOptions.fallback}`) {
+        case 'true-false':
+          return { i18nMessages, i18nStrings: {} };
+        case 'true-true':
+          return { i18nMessages: i18nMessagesFallback, i18nStrings: {} };
+        case 'false-false':
+          return { i18nMessages, i18nStrings };
+        case 'false-true':
+        default:
+          return { i18nMessages, i18nStrings: i18nStringsFallback };
+      }
+    };
+
+    test('date only iso inputs use correct i18n strings', () => {
+      const dateOnlyIsoProps = { ...randomItem(isoDateProps), dateOnly: true, value: null };
+      const result = renderDateRangePicker({ ...dateOnlyIsoProps, ...messages({ i18n: true, fallback: false }) });
+      assertDateInput('YYYY-MM-DD', '(i18n) For date, use YYYY-MM-DD.');
+
+      result.rerender({ ...dateOnlyIsoProps, ...messages({ i18n: true, fallback: true }) });
+      assertDateInput('YYYY-MM-DD', '(i18n) (fallback) For date, use YYYY-MM-DD.');
+
+      result.rerender({ ...dateOnlyIsoProps, ...messages({ i18n: false, fallback: false }) });
+      assertDateInput('YYYY-MM-DD', 'For date, use YYYY-MM-DD.');
+
+      result.rerender({ ...dateOnlyIsoProps, ...messages({ i18n: false, fallback: true }) });
+      assertDateInput('YYYY-MM-DD', '(fallback) For date, use YYYY-MM-DD.');
+    });
+
+    test.each(['hh:mm:ss', 'hh:mm', 'hh'] as const)(
+      'date/time iso inputs use correct i18n strings, timeInputFormat=%s',
+      timeInputFormat => {
+        const dateTimeIsoProps = { ...randomItem(isoDateProps), dateOnly: false, value: null, timeInputFormat };
+        const result = renderDateRangePicker({ ...dateTimeIsoProps, ...messages({ i18n: true, fallback: false }) });
+        assertDateInput('YYYY-MM-DD', '(i18n) For date, use YYYY-MM-DD. For time, use 24 hour format.');
+        assertTimeInput(timeInputFormat, '(i18n) For date, use YYYY-MM-DD. For time, use 24 hour format.');
+
+        result.rerender({ ...dateTimeIsoProps, ...messages({ i18n: true, fallback: true }) });
+        assertDateInput('YYYY-MM-DD', '(i18n) (fallback) For date, use YYYY-MM-DD. For time, use 24 hour format.');
+        assertTimeInput(timeInputFormat, '(i18n) (fallback) For date, use YYYY-MM-DD. For time, use 24 hour format.');
+
+        result.rerender({ ...dateTimeIsoProps, ...messages({ i18n: false, fallback: false }) });
+        assertDateInput('YYYY-MM-DD', 'For date, use YYYY-MM-DD. For time, use 24 hour format.');
+        assertTimeInput(timeInputFormat, 'For date, use YYYY-MM-DD. For time, use 24 hour format.');
+
+        result.rerender({ ...dateTimeIsoProps, ...messages({ i18n: false, fallback: true }) });
+        assertDateInput('YYYY-MM-DD', '(fallback) For date, use YYYY-MM-DD. For time, use 24 hour format.');
+        assertTimeInput(timeInputFormat, '(fallback) For date, use YYYY-MM-DD. For time, use 24 hour format.');
+      }
+    );
+
+    test('date only slashed inputs use correct i18n strings', () => {
+      const dateOnlySlashedProps = { ...randomItem(slashedDateProps), dateOnly: true, value: null };
+      const result = renderDateRangePicker({ ...dateOnlySlashedProps, ...messages({ i18n: true, fallback: false }) });
+      assertDateInput('YYYY/MM/DD', '(i18n) For date, use YYYY/MM/DD.');
+
+      result.rerender({ ...dateOnlySlashedProps, ...messages({ i18n: true, fallback: true }) });
+      assertDateInput('YYYY/MM/DD', '(i18n) (fallback) For date, use YYYY-MM-DD.');
+
+      result.rerender({ ...dateOnlySlashedProps, ...messages({ i18n: false, fallback: false }) });
+      assertDateInput('YYYY/MM/DD', 'For date, use YYYY/MM/DD.');
+
+      result.rerender({ ...dateOnlySlashedProps, ...messages({ i18n: false, fallback: true }) });
+      assertDateInput('YYYY/MM/DD', '(fallback) For date, use YYYY-MM-DD.');
+    });
+
+    test('date/time slashed inputs use correct i18n strings', () => {
+      const dateTimeSlashedProps = { ...randomItem(slashedDateProps), dateOnly: false, value: null };
+      const result = renderDateRangePicker({ ...dateTimeSlashedProps, ...messages({ i18n: true, fallback: false }) });
+      assertDateInput('YYYY/MM/DD', '(i18n) For date, use YYYY/MM/DD. For time, use 24 hour format.');
+      assertTimeInput('hh:mm:ss', '(i18n) For date, use YYYY/MM/DD. For time, use 24 hour format.');
+
+      result.rerender({ ...dateTimeSlashedProps, ...messages({ i18n: true, fallback: true }) });
+      assertDateInput('YYYY/MM/DD', '(i18n) (fallback) For date, use YYYY-MM-DD. For time, use 24 hour format.');
+      assertTimeInput('hh:mm:ss', '(i18n) (fallback) For date, use YYYY-MM-DD. For time, use 24 hour format.');
+
+      result.rerender({ ...dateTimeSlashedProps, ...messages({ i18n: false, fallback: false }) });
+      assertDateInput('YYYY/MM/DD', 'For date, use YYYY/MM/DD. For time, use 24 hour format.');
+      assertTimeInput('hh:mm:ss', 'For date, use YYYY/MM/DD. For time, use 24 hour format.');
+
+      result.rerender({ ...dateTimeSlashedProps, ...messages({ i18n: false, fallback: true }) });
+      assertDateInput('YYYY/MM/DD', '(fallback) For date, use YYYY-MM-DD. For time, use 24 hour format.');
+      assertTimeInput('hh:mm:ss', '(fallback) For date, use YYYY-MM-DD. For time, use 24 hour format.');
+    });
+
+    test('month iso inputs use correct i18n strings', () => {
+      const dateOnlyIsoProps = { ...randomItem(isoDateProps), granularity: 'month' as const, value: null };
+      const result = renderDateRangePicker({ ...dateOnlyIsoProps, ...messages({ i18n: true, fallback: false }) });
+      assertDateInput('YYYY-MM', '(i18n) For month, use YYYY-MM.');
+
+      result.rerender({ ...dateOnlyIsoProps, ...messages({ i18n: true, fallback: true }) });
+      assertDateInput('YYYY-MM', '(i18n) (fallback) For month, use YYYY-MM.');
+
+      result.rerender({ ...dateOnlyIsoProps, ...messages({ i18n: false, fallback: false }) });
+      assertDateInput('YYYY-MM', 'For month, use YYYY-MM.');
+
+      result.rerender({ ...dateOnlyIsoProps, ...messages({ i18n: false, fallback: true }) });
+      assertDateInput('YYYY-MM', '(fallback) For month, use YYYY-MM.');
+    });
+
+    test('month slashed inputs use correct i18n strings', () => {
+      const dateOnlyIsoProps = { ...randomItem(slashedDateProps), granularity: 'month' as const, value: null };
+      const result = renderDateRangePicker({ ...dateOnlyIsoProps, ...messages({ i18n: true, fallback: false }) });
+      assertDateInput('YYYY/MM', '(i18n) For month, use YYYY/MM.');
+
+      result.rerender({ ...dateOnlyIsoProps, ...messages({ i18n: true, fallback: true }) });
+      assertDateInput('YYYY/MM', '(i18n) (fallback) For month, use YYYY-MM.');
+
+      result.rerender({ ...dateOnlyIsoProps, ...messages({ i18n: false, fallback: false }) });
+      assertDateInput('YYYY/MM', 'For month, use YYYY/MM.');
+
+      result.rerender({ ...dateOnlyIsoProps, ...messages({ i18n: false, fallback: true }) });
+      assertDateInput('YYYY/MM', '(fallback) For month, use YYYY-MM.');
+    });
+  });
+});
diff --git a/src/date-range-picker/__tests__/date-range-picker-absolute.test.tsx b/src/date-range-picker/__tests__/date-range-picker-absolute.test.tsx
index f5273a27a8..852e0f53b2 100644
--- a/src/date-range-picker/__tests__/date-range-picker-absolute.test.tsx
+++ b/src/date-range-picker/__tests__/date-range-picker-absolute.test.tsx
@@ -107,7 +107,7 @@ describe('Date range picker', () => {
         });
       });
 
-      describe('data formats', () => {
+      describe('date formats', () => {
         test(`granularity of month overrides dateOnly and parses out milliseconds`, () => {
           const { wrapper } = renderDateRangePicker({
             ...defaultProps,
@@ -516,7 +516,7 @@ describe('Date range picker', () => {
           );
         });
 
-        testIf(granularity === 'day')('hh:mm:ss gets hidded when dateOnly', () => {
+        testIf(granularity === 'day')('hh:mm:ss gets hidden when dateOnly', () => {
           const onChangeSpy = jest.fn();
           const { wrapper } = renderDateRangePicker({
             ...defaultProps,
diff --git a/src/date-range-picker/__tests__/i18n-strings.ts b/src/date-range-picker/__tests__/i18n-strings.ts
index fa257c60a0..a6a2ec7c31 100644
--- a/src/date-range-picker/__tests__/i18n-strings.ts
+++ b/src/date-range-picker/__tests__/i18n-strings.ts
@@ -17,9 +17,9 @@ export const i18nStrings: DateRangePickerProps.I18nStrings = {
   customRelativeRangeUnitLabel: 'Unit of time',
   formatRelativeRange: range => `${range.unit}${range.amount}`,
   formatUnit: (unit, value) => (value === 1 ? unit : `${unit}s`),
-  dateConstraintText: 'Range must be between 6 and 30 days.',
-  dateTimeConstraintText: 'Range must be between 6 and 30 days. Use 24 hour format.',
-  monthConstraintText: 'For month use YYYY/MM.',
+  dateConstraintText: '(fallback) For date, use YYYY-MM-DD.',
+  dateTimeConstraintText: '(fallback) For date, use YYYY-MM-DD. For time, use 24 hour format.',
+  monthConstraintText: '(fallback) For month, use YYYY-MM.',
   modeSelectionLabel: 'Date range mode',
   relativeModeTitle: 'Relative range',
   absoluteModeTitle: 'Absolute range',
@@ -35,3 +35,29 @@ export const i18nStrings: DateRangePickerProps.I18nStrings = {
   applyButtonLabel: 'Apply',
   renderSelectedAbsoluteRangeAriaLive: () => `Range selected from A to B`,
 };
+
+export const i18nStringsWithExtraFormatConstraints: DateRangePickerProps.I18nStrings = {
+  ...i18nStrings,
+  slashedDateConstraintText: 'For date, use YYYY/MM/DD.',
+  slashedDateTimeConstraintText: 'For date, use YYYY/MM/DD. For time, use 24 hour format.',
+  isoDateConstraintText: 'For date, use YYYY-MM-DD.',
+  isoDateTimeConstraintText: 'For date, use YYYY-MM-DD. For time, use 24 hour format.',
+  slashedMonthConstraintText: 'For month, use YYYY/MM.',
+  isoMonthConstraintText: 'For month, use YYYY-MM.',
+};
+
+function createI18nMessages(i18nStrings: DateRangePickerProps.I18nStrings) {
+  return Object.entries(i18nStrings).reduce(
+    (acc, [key, value]) => {
+      if (typeof value === 'string') {
+        acc['date-range-picker'][`i18nStrings.${key}`] = `(i18n) ${value}`;
+      }
+      return acc;
+    },
+    { 'date-range-picker': {} } as Record<string, Record<string, string>>
+  );
+}
+
+export const i18nMessages = createI18nMessages(i18nStrings);
+
+export const i18nMessagesWithExtraFormatConstraints = createI18nMessages(i18nStringsWithExtraFormatConstraints);
diff --git a/src/date-range-picker/calendar/index.tsx b/src/date-range-picker/calendar/index.tsx
index 04ffa49783..84de2b5adb 100644
--- a/src/date-range-picker/calendar/index.tsx
+++ b/src/date-range-picker/calendar/index.tsx
@@ -18,39 +18,26 @@ import {
 
 import { useUniqueId } from '@cloudscape-design/component-toolkit/internal';
 
-import { CalendarProps } from '../../calendar/interfaces';
 import { getDateLabel, renderTimeLabel } from '../../calendar/utils/intl';
 import { getBaseDay } from '../../calendar/utils/navigation-day';
 import { getBaseMonth } from '../../calendar/utils/navigation-month';
 import { useInternalI18n } from '../../i18n/context.js';
-import { BaseComponentProps } from '../../internal/base-component';
 import { useMobile } from '../../internal/hooks/use-mobile/index.js';
 import { formatDate, formatDateTime, parseDate, splitDateTime } from '../../internal/utils/date-time';
 import { normalizeLocale, normalizeStartOfWeek } from '../../internal/utils/locale';
 import InternalLiveRegion from '../../live-region/internal';
 import SpaceBetween from '../../space-between/internal';
-import { TimeInputProps } from '../../time-input/interfaces';
-import { DateRangePickerProps, RangeCalendarI18nStrings } from '../interfaces';
+import { DateRangePickerProps } from '../interfaces';
 import { Grids } from './grids';
 import CalendarHeader from './header';
+import { DateRangePickerCalendarProps } from './interfaces';
 import RangeInputs from './range-inputs.js';
 import { findDateToFocus, findMonthToDisplay, findMonthToFocus, findYearToDisplay } from './utils';
 
 import styles from '../styles.css.js';
 import testutilStyles from '../test-classes/styles.css.js';
 
-export interface DateRangePickerCalendarProps extends BaseComponentProps, Pick<CalendarProps, 'granularity'> {
-  value: DateRangePickerProps.PendingAbsoluteValue;
-  setValue: React.Dispatch<React.SetStateAction<DateRangePickerProps.PendingAbsoluteValue>>;
-  locale?: string;
-  startOfWeek?: number;
-  isDateEnabled?: (date: Date) => boolean;
-  dateDisabledReason?: (date: Date) => string;
-  i18nStrings?: RangeCalendarI18nStrings;
-  dateOnly?: boolean;
-  timeInputFormat?: TimeInputProps.Format;
-  customAbsoluteRangeControl: DateRangePickerProps.AbsoluteRangeControl | undefined;
-}
+export { DateRangePickerCalendarProps };
 
 export default function DateRangePickerCalendar({
   value,
@@ -61,7 +48,8 @@ export default function DateRangePickerCalendar({
   dateDisabledReason = () => '',
   i18nStrings,
   dateOnly = false,
-  timeInputFormat = 'hh:mm:ss',
+  timeInputFormat,
+  dateInputFormat,
   customAbsoluteRangeControl,
   granularity = 'day',
 }: DateRangePickerCalendarProps) {
@@ -302,6 +290,7 @@ export default function DateRangePickerCalendar({
             i18nStrings={i18nStrings}
             dateOnly={dateOnly}
             timeInputFormat={timeInputFormat}
+            dateInputFormat={dateInputFormat}
             granularity={granularity}
           />
           {customAbsoluteRangeControl && <div>{customAbsoluteRangeControl(value, interceptedSetValue)}</div>}
diff --git a/src/date-range-picker/calendar/interfaces.ts b/src/date-range-picker/calendar/interfaces.ts
new file mode 100644
index 0000000000..2cdc14878b
--- /dev/null
+++ b/src/date-range-picker/calendar/interfaces.ts
@@ -0,0 +1,72 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { BaseComponentProps } from '../../internal/base-component';
+import { SomeRequired } from '../../internal/types';
+import { DateRangePickerProps } from '../interfaces';
+
+export type RangeCalendarI18nStrings = Pick<
+  DateRangePickerProps.I18nStrings,
+  | 'todayAriaLabel'
+  | 'nextMonthAriaLabel'
+  | 'previousMonthAriaLabel'
+  | 'currentMonthAriaLabel'
+  | 'nextYearAriaLabel'
+  | 'previousYearAriaLabel'
+  | 'startMonthLabel'
+  | 'startDateLabel'
+  | 'startTimeLabel'
+  | 'endMonthLabel'
+  | 'endDateLabel'
+  | 'endTimeLabel'
+  | 'dateConstraintText'
+  | 'isoDateConstraintText'
+  | 'slashedDateConstraintText'
+  | 'dateTimeConstraintText'
+  | 'isoDateTimeConstraintText'
+  | 'slashedDateTimeConstraintText'
+  | 'monthConstraintText'
+  | 'isoMonthConstraintText'
+  | 'slashedMonthConstraintText'
+  | 'renderSelectedAbsoluteRangeAriaLive'
+>;
+
+export interface DateRangePickerCalendarProps
+  extends BaseComponentProps,
+    SomeRequired<
+      Pick<
+        DateRangePickerProps,
+        | 'granularity'
+        | 'locale'
+        | 'startOfWeek'
+        | 'timeInputFormat'
+        | 'dateInputFormat'
+        | 'i18nStrings'
+        | 'dateOnly'
+        | 'absoluteFormat'
+        | 'customAbsoluteRangeControl'
+        | 'isDateEnabled'
+        | 'dateDisabledReason'
+      >,
+      'absoluteFormat' | 'timeInputFormat'
+    > {
+  value: DateRangePickerProps.PendingAbsoluteValue;
+  setValue: React.Dispatch<React.SetStateAction<DateRangePickerProps.PendingAbsoluteValue>>;
+  i18nStrings?: RangeCalendarI18nStrings;
+}
+
+export interface RangeInputsProps
+  extends BaseComponentProps,
+    SomeRequired<
+      Pick<DateRangePickerProps, 'granularity' | 'dateOnly' | 'timeInputFormat' | 'dateInputFormat'>,
+      'dateOnly' | 'timeInputFormat' | 'granularity'
+    > {
+  startDate: string;
+  onChangeStartDate: (value: string) => void;
+  startTime: string;
+  onChangeStartTime: (value: string) => void;
+  endDate: string;
+  onChangeEndDate: (value: string) => void;
+  endTime: string;
+  onChangeEndTime: (value: string) => void;
+  i18nStrings?: RangeCalendarI18nStrings;
+}
diff --git a/src/date-range-picker/calendar/range-inputs.tsx b/src/date-range-picker/calendar/range-inputs.tsx
index 703139f67f..6980b23e25 100644
--- a/src/date-range-picker/calendar/range-inputs.tsx
+++ b/src/date-range-picker/calendar/range-inputs.tsx
@@ -4,45 +4,16 @@
 import React from 'react';
 import clsx from 'clsx';
 
-import { CalendarProps } from '../../calendar/interfaces';
 import InternalDateInput from '../../date-input/internal';
 import InternalFormField from '../../form-field/internal';
 import { useInternalI18n } from '../../i18n/context.js';
-import { BaseComponentProps } from '../../internal/base-component';
-import { TimeInputProps } from '../../time-input/interfaces';
 import InternalTimeInput from '../../time-input/internal';
-import { RangeCalendarI18nStrings } from '../interfaces';
+import { RangeInputsProps } from './interfaces';
+import { generateI18NFallbackKey, generateI18NKey, provideI18N } from './utils';
 
 import styles from '../styles.css.js';
 import testutilStyles from '../test-classes/styles.css.js';
 
-type I18nStrings = Pick<
-  RangeCalendarI18nStrings,
-  | 'dateConstraintText'
-  | 'dateTimeConstraintText'
-  | 'monthConstraintText'
-  | 'startMonthLabel'
-  | 'startDateLabel'
-  | 'startTimeLabel'
-  | 'endMonthLabel'
-  | 'endDateLabel'
-  | 'endTimeLabel'
->;
-
-interface RangeInputsProps extends BaseComponentProps, Pick<CalendarProps, 'granularity'> {
-  startDate: string;
-  onChangeStartDate: (value: string) => void;
-  startTime: string;
-  onChangeStartTime: (value: string) => void;
-  endDate: string;
-  onChangeEndDate: (value: string) => void;
-  endTime: string;
-  onChangeEndTime: (value: string) => void;
-  i18nStrings?: I18nStrings;
-  dateOnly: boolean;
-  timeInputFormat: TimeInputProps.Format;
-}
-
 export default function RangeInputs({
   startDate,
   onChangeStartDate,
@@ -55,28 +26,20 @@ export default function RangeInputs({
   i18nStrings,
   dateOnly,
   timeInputFormat,
-  granularity = 'day',
+  dateInputFormat,
+  granularity,
 }: RangeInputsProps) {
   const i18n = useInternalI18n('date-range-picker');
   const isMonthPicker = granularity === 'month';
-  const dateInputPlaceholder = isMonthPicker ? 'YYYY/MM' : 'YYYY/MM/DD';
   const showTimeInput = !dateOnly && !isMonthPicker;
-
+  const isIso = dateInputFormat === 'iso';
+  const separator = isIso ? '-' : '/';
+  const dateInputPlaceholder = `YYYY${separator}MM${isMonthPicker ? '' : `${separator}DD`}`;
+  const i18nProvided = provideI18N(i18nStrings!, isMonthPicker, dateOnly, isIso);
+  const i18nKey = generateI18NKey(isMonthPicker, dateOnly, isIso);
+  const i18nFallbackKey = generateI18NFallbackKey(isMonthPicker, dateOnly);
   return (
-    <InternalFormField
-      constraintText={i18n(
-        isMonthPicker
-          ? 'i18nStrings.monthConstraintText'
-          : dateOnly
-            ? 'i18nStrings.dateConstraintText'
-            : 'i18nStrings.dateTimeConstraintText',
-        isMonthPicker
-          ? i18nStrings?.monthConstraintText
-          : dateOnly
-            ? i18nStrings?.dateConstraintText
-            : i18nStrings?.dateTimeConstraintText
-      )}
-    >
+    <InternalFormField constraintText={i18n(i18nKey, i18nProvided) || i18n(i18nFallbackKey, i18nProvided)}>
       <div className={styles['date-and-time-container']}>
         <div className={styles['date-and-time-wrapper']}>
           <InternalFormField
@@ -90,6 +53,7 @@ export default function RangeInputs({
               value={startDate}
               className={clsx(testutilStyles['start-date-input'], isMonthPicker && testutilStyles['start-month-input'])}
               onChange={event => onChangeStartDate(event.detail.value)}
+              format={dateInputFormat}
               placeholder={dateInputPlaceholder}
               granularity={granularity}
             />
@@ -119,6 +83,7 @@ export default function RangeInputs({
               value={endDate}
               className={clsx(testutilStyles['end-date-input'], isMonthPicker && testutilStyles['end-month-picker'])}
               onChange={event => onChangeEndDate(event.detail.value)}
+              format={dateInputFormat}
               placeholder={dateInputPlaceholder}
               granularity={granularity}
             />
diff --git a/src/date-range-picker/calendar/utils.ts b/src/date-range-picker/calendar/utils.ts
index bd9fa52218..0dc45f6b90 100644
--- a/src/date-range-picker/calendar/utils.ts
+++ b/src/date-range-picker/calendar/utils.ts
@@ -4,6 +4,7 @@ import { addMonths, addYears, isSameMonth, isSameYear, startOfMonth, startOfYear
 
 import { parseDate } from '../../internal/utils/date-time';
 import { DateRangePickerProps } from '../interfaces';
+import { RangeCalendarI18nStrings } from './interfaces';
 
 export function findDateToFocus(
   selected: Date | null,
@@ -69,3 +70,50 @@ export function findYearToDisplay(value: DateRangePickerProps.PendingAbsoluteVal
   }
   return startOfYear(Date.now());
 }
+
+export const generateI18NFallbackKey = (isMonthPicker: boolean, isDateOnly: boolean) => {
+  if (isMonthPicker) {
+    return 'i18nStrings.monthConstraintText';
+  }
+  if (isDateOnly) {
+    return 'i18nStrings.dateConstraintText';
+  }
+  return 'i18nStrings.dateTimeConstraintText';
+};
+
+export const generateI18NKey = (isMonthPicker: boolean, isDateOnly: boolean, isIso: boolean) => {
+  if (isMonthPicker) {
+    return isIso ? 'i18nStrings.isoMonthConstraintText' : 'i18nStrings.slashedMonthConstraintText';
+  }
+  if (isDateOnly) {
+    return isIso ? 'i18nStrings.isoDateConstraintText' : 'i18nStrings.slashedDateConstraintText';
+  }
+  return isIso ? 'i18nStrings.isoDateTimeConstraintText' : 'i18nStrings.slashedDateTimeConstraintText';
+};
+
+export const provideI18N = (
+  i18nStrings: RangeCalendarI18nStrings,
+  isMonthPicker: boolean,
+  isDateOnly: boolean,
+  isIso: boolean
+): undefined | string => {
+  let result;
+  if (isMonthPicker) {
+    result = isIso ? i18nStrings?.isoMonthConstraintText : i18nStrings?.slashedMonthConstraintText;
+    if (!result) {
+      result = i18nStrings?.monthConstraintText;
+    }
+  } else if (isDateOnly) {
+    result = isIso ? i18nStrings?.isoDateConstraintText : i18nStrings?.slashedDateConstraintText;
+    if (!result) {
+      result = i18nStrings?.dateConstraintText;
+    }
+  }
+  if (!result) {
+    result = isIso ? i18nStrings?.isoDateTimeConstraintText : i18nStrings?.slashedDateTimeConstraintText;
+    if (!result) {
+      result = i18nStrings?.dateTimeConstraintText;
+    }
+  }
+  return result;
+};
diff --git a/src/date-range-picker/dropdown.tsx b/src/date-range-picker/dropdown.tsx
index 48e7301813..f9d45ed3a6 100644
--- a/src/date-range-picker/dropdown.tsx
+++ b/src/date-range-picker/dropdown.tsx
@@ -11,6 +11,7 @@ import { InternalButton } from '../button/internal';
 import { CalendarProps } from '../calendar/interfaces';
 import { useInternalI18n } from '../i18n/context';
 import FocusLock from '../internal/components/focus-lock';
+import { SomeRequired } from '../internal/types';
 import InternalLiveRegion, { InternalLiveRegionRef } from '../live-region/internal';
 import InternalSpaceBetween from '../space-between/internal';
 import Calendar from './calendar';
@@ -37,17 +38,22 @@ interface DateRangePickerDropdownProps
       | 'dateOnly'
       | 'rangeSelectorMode'
     >,
-    Pick<
-      DateRangePickerProps,
-      | 'startOfWeek'
-      | 'getTimeOffset'
-      | 'timeInputFormat'
-      | 'timeOffset'
-      | 'ariaLabelledby'
-      | 'ariaDescribedby'
-      | 'i18nStrings'
-      | 'customRelativeRangeUnits'
-      | 'dateDisabledReason'
+    SomeRequired<
+      Pick<
+        DateRangePickerProps,
+        | 'startOfWeek'
+        | 'getTimeOffset'
+        | 'absoluteFormat'
+        | 'timeInputFormat'
+        | 'dateInputFormat'
+        | 'timeOffset'
+        | 'ariaLabelledby'
+        | 'ariaDescribedby'
+        | 'i18nStrings'
+        | 'customRelativeRangeUnits'
+        | 'dateDisabledReason'
+      >,
+      'absoluteFormat' | 'timeInputFormat'
     >,
     Pick<CalendarProps, 'granularity'> {
   onClear: () => void;
@@ -74,7 +80,9 @@ export function DateRangePickerDropdown({
   isSingleGrid,
   i18nStrings,
   dateOnly,
+  absoluteFormat,
   timeInputFormat,
+  dateInputFormat,
   rangeSelectorMode,
   ariaLabelledby,
   ariaDescribedby,
@@ -201,7 +209,9 @@ export function DateRangePickerDropdown({
                       dateDisabledReason={dateDisabledReason}
                       i18nStrings={i18nStrings}
                       dateOnly={dateOnly}
+                      absoluteFormat={absoluteFormat}
                       timeInputFormat={timeInputFormat}
+                      dateInputFormat={dateInputFormat}
                       customAbsoluteRangeControl={customAbsoluteRangeControl}
                       granularity={granularity}
                     />
diff --git a/src/date-range-picker/index.tsx b/src/date-range-picker/index.tsx
index 6c3399e862..3164f2250d 100644
--- a/src/date-range-picker/index.tsx
+++ b/src/date-range-picker/index.tsx
@@ -107,6 +107,7 @@ const DateRangePicker = React.forwardRef(
       timeOffset,
       getTimeOffset,
       timeInputFormat = 'hh:mm:ss',
+      dateInputFormat = 'slashed',
       expandToViewport = false,
       rangeSelectorMode = 'default',
       customAbsoluteRangeControl,
@@ -127,6 +128,7 @@ const DateRangePicker = React.forwardRef(
         readOnly,
         showClearButton,
         timeInputFormat,
+        dateInputFormat,
         hideTimeOffset,
         granularity,
       },
@@ -338,7 +340,9 @@ const DateRangePicker = React.forwardRef(
                 relativeOptions={relativeOptions}
                 isValidRange={isValidRange}
                 dateOnly={dateOnly}
+                absoluteFormat={absoluteFormat}
                 timeInputFormat={timeInputFormat}
+                dateInputFormat={dateInputFormat}
                 rangeSelectorMode={rangeSelectorMode}
                 ariaLabelledby={ariaLabelledby}
                 ariaDescribedby={ariaDescribedby}
diff --git a/src/date-range-picker/interfaces.ts b/src/date-range-picker/interfaces.ts
index c98bc1cfeb..48d64cb432 100644
--- a/src/date-range-picker/interfaces.ts
+++ b/src/date-range-picker/interfaces.ts
@@ -7,6 +7,7 @@ import { BaseComponentProps } from '../internal/base-component';
 import { ExpandToViewport } from '../internal/components/dropdown/interfaces';
 import { FormFieldValidationControlProps } from '../internal/context/form-field-context';
 import { NonCancelableEventHandler } from '../internal/events';
+import { DateFormat, EditableDateFormat } from '../internal/utils/date-time/interfaces';
 import { TimeInputProps } from '../time-input/interfaces';
 
 export interface DateRangePickerBaseProps {
@@ -81,6 +82,15 @@ export interface DateRangePickerBaseProps {
    */
   rangeSelectorMode?: DateRangePickerProps.RangeSelectorMode;
 
+  /**
+   * Specifies the date format to use on the date inputs in the absolute dropdown.
+   *
+   * The format of the input as it is being interacted with. It can take the following values:
+   * * `iso`: ISO 8601 format without time, e.g.: 2024-01-30 (or 2024-01)
+   * * `slashed`: similar to ISO 8601 but with '/' in place of '-'. e.g.: 2024/01/30 (or 2024/01)
+   */
+  dateInputFormat?: DateRangePickerProps.DateInputFormat;
+
   /**
    * Specifies the format of the time input for absolute ranges.
    *
@@ -88,7 +98,7 @@ export interface DateRangePickerBaseProps {
    *
    * Has no effect when `dateOnly` is true or `granularity` is set to 'month'.
    */
-  timeInputFormat?: TimeInputProps.Format;
+  timeInputFormat?: DateRangePickerProps.TimeInputFormat;
 
   /**
    * Fired whenever a user changes the component's value.
@@ -183,8 +193,7 @@ export interface DateRangePickerProps
    * It can take the following values:
    * * `iso`: ISO 8601 format, e.g.: 2024-01-30T13:32:32+01:00 (or 2024-01-30 when `dateOnly` is true)
    * * `long-localized`: a more human-readable, localized format, e.g.: January 30, 2024, 13:32:32 (UTC+1) (or January 30, 2024 when `dateOnly` is true)
-   *
-   * Defaults to `iso`.
+   * * `slashed`: similar to ISO 8601 but with '/' in place of '-'. e.g.: 2024/01/30 (or 2024/01)
    */
   absoluteFormat?: DateRangePickerProps.AbsoluteFormat;
 
@@ -438,8 +447,9 @@ export namespace DateRangePickerProps {
     endDateLabel?: string;
 
     /**
-     * Visible label for the End Time input for the
-     * absolute range.
+     * Visible label for the End Time input for the absolute range.
+     * This serves as a fallback if no format specific date constraint test is provided
+     *
      * @i18n
      */
     endTimeLabel?: string;
@@ -452,19 +462,57 @@ export namespace DateRangePickerProps {
     dateConstraintText?: string;
 
     /**
-     * Constraint text for the input fields for the
-     * absolute range.
+     * Constraint text for the input fields for the absolute range in 'slashed' format with no time option.
+     * @i18n
+     */
+    slashedDateConstraintText?: string;
+
+    /**
+     * Constraint text for the input fields for the absolute range in 'iso' format with no time option.
+     * @i18n
+     */
+    isoDateConstraintText?: string;
+
+    /**
+     * Constraint text for the input fields for the absolute range.
+     * This serves as a fallback if no format specific datetime constraint test is provided
+     *
      * @i18n
      */
     dateTimeConstraintText?: string;
 
     /**
-     * Constraint text for the month input fields for the
-     * absolute range.
+     * Constraint text for the date input fields for the absolute range in 'slashed' format.
+     * @i18n
+     */
+    slashedDateTimeConstraintText?: string;
+
+    /**
+     * Constraint text for the date input fields for the absolute range in 'iso' format with.
+     * @i18n
+     */
+    isoDateTimeConstraintText?: string;
+
+    /**
+     * Constraint text for the month input fields for the absolute range.
+     * This serves as a fallback if no format specific month constraint test is provided.
+     *
      * @i18n
      */
     monthConstraintText?: string;
 
+    /**
+     * Constraint text for the month input fields for the absolute range in 'slashed' format.
+     * @i18n
+     */
+    slashedMonthConstraintText?: string;
+
+    /**
+     * Constraint text for the month input fields for the absolute range in 'iso' format.
+     * @i18n
+     */
+    isoMonthConstraintText?: string;
+
     /**
      * Provides a text alternative for the error icon in the error alert.
      * @i18n
@@ -513,29 +561,13 @@ export namespace DateRangePickerProps {
     previousYearAriaLabel?: string;
   }
 
-  export type AbsoluteFormat = 'iso' | 'long-localized';
+  export type AbsoluteFormat = DateFormat;
+
+  export type DateInputFormat = EditableDateFormat | undefined;
+
+  export type TimeInputFormat = TimeInputProps.Format;
 }
 
 export type DayIndex = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 
 export type QuarterIndex = 0 | 1 | 2;
-
-export type RangeCalendarI18nStrings = Pick<
-  DateRangePickerProps.I18nStrings,
-  | 'todayAriaLabel'
-  | 'nextMonthAriaLabel'
-  | 'previousMonthAriaLabel'
-  | 'currentMonthAriaLabel'
-  | 'nextYearAriaLabel'
-  | 'previousYearAriaLabel'
-  | 'startMonthLabel'
-  | 'startDateLabel'
-  | 'startTimeLabel'
-  | 'endMonthLabel'
-  | 'endDateLabel'
-  | 'endTimeLabel'
-  | 'dateConstraintText'
-  | 'dateTimeConstraintText'
-  | 'monthConstraintText'
-  | 'renderSelectedAbsoluteRangeAriaLive'
->;
diff --git a/src/internal/utils/date-time/__tests__/format-date-time-with-offset.test.ts b/src/internal/utils/date-time/__tests__/format-date-time-with-offset.test.ts
index f2bdd5f291..1e0c2ab7f7 100644
--- a/src/internal/utils/date-time/__tests__/format-date-time-with-offset.test.ts
+++ b/src/internal/utils/date-time/__tests__/format-date-time-with-offset.test.ts
@@ -14,15 +14,12 @@ describe('formatDateTimeWithOffset', () => {
       {
         date: '2020-01-01',
         timeOffset: browser,
-        expected: {
-          iso: '2020-01-01',
-          localized: { 'en-US': 'January 1, 2020' },
-        },
+        expected: { iso: '2020-01-01', slashed: '2020/01/01', localized: { 'en-US': 'January 1, 2020' } },
       },
       {
         date: '2020-01-01',
         timeOffset: berlin,
-        expected: { iso: '2020-01-01', localized: { 'en-US': 'January 1, 2020' } },
+        expected: { iso: '2020-01-01', slashed: '2020/01/01', localized: { 'en-US': 'January 1, 2020' } },
       },
     ];
     describe.each(cases)(
@@ -31,6 +28,9 @@ describe('formatDateTimeWithOffset', () => {
         test('ISO', () => {
           expect(formatDateTimeWithOffset({ date, timeOffset, format: 'iso' })).toBe(expected.iso);
         });
+        test('slashed', () => {
+          expect(formatDateTimeWithOffset({ date, timeOffset, format: 'slashed' })).toBe(expected.slashed);
+        });
         test('Human-readable', () => {
           expect(formatDateTimeWithOffset({ date, timeOffset, format: 'long-localized', locale: 'en-US' })).toBe(
             expected.localized['en-US']
@@ -48,6 +48,7 @@ describe('formatDateTimeWithOffset', () => {
           timeOffset: berlin,
           expected: {
             iso: '2020-01-01T00:00:00+02:00',
+            slashed: '2020/01/01T00:00:00+02:00',
             localized: { 'en-US': 'January 1, 2020, 00:00:00 (UTC+2)' },
           },
         },
@@ -56,6 +57,7 @@ describe('formatDateTimeWithOffset', () => {
           timeOffset: newYork,
           expected: {
             iso: '2020-01-01T00:00:00-04:00',
+            slashed: '2020/01/01T00:00:00-04:00',
             localized: { 'en-US': 'January 1, 2020, 00:00:00 (UTC-4)' },
           },
         },
@@ -64,6 +66,7 @@ describe('formatDateTimeWithOffset', () => {
           timeOffset: regional,
           expected: {
             iso: '2020-01-01T00:00:00Z',
+            slashed: '2020/01/01T00:00:00Z',
             localized: { 'en-US': 'January 1, 2020, 00:00:00 (UTC)' },
           },
         },
@@ -74,6 +77,9 @@ describe('formatDateTimeWithOffset', () => {
           test('ISO', () => {
             expect(formatDateTimeWithOffset({ date, timeOffset, format: 'iso' })).toBe(expected.iso);
           });
+          test('slashed', () => {
+            expect(formatDateTimeWithOffset({ date, timeOffset, format: 'slashed' })).toBe(expected.slashed);
+          });
           test('Human-readable', () => {
             expect(formatDateTimeWithOffset({ date, timeOffset, format: 'long-localized', locale: 'en-US' })).toBe(
               expected.localized['en-US']
@@ -90,6 +96,7 @@ describe('formatDateTimeWithOffset', () => {
           timeOffset: berlin,
           expected: {
             iso: '2020-01-01T00:00:00',
+            slashed: '2020/01/01T00:00:00',
             localized: { 'en-US': 'January 1, 2020, 00:00:00' },
           },
         },
@@ -98,6 +105,7 @@ describe('formatDateTimeWithOffset', () => {
           timeOffset: newYork,
           expected: {
             iso: '2020-01-01T00:00:00',
+            slashed: '2020/01/01T00:00:00',
             localized: { 'en-US': 'January 1, 2020, 00:00:00' },
           },
         },
@@ -106,6 +114,7 @@ describe('formatDateTimeWithOffset', () => {
           timeOffset: regional,
           expected: {
             iso: '2020-01-01T00:00:00',
+            slashed: '2020/01/01T00:00:00',
             localized: { 'en-US': 'January 1, 2020, 00:00:00' },
           },
         },
@@ -119,6 +128,11 @@ describe('formatDateTimeWithOffset', () => {
               expected.iso
             );
           });
+          test('slashed', () => {
+            expect(formatDateTimeWithOffset({ date, timeOffset, hideTimeOffset: true, format: 'slashed' })).toBe(
+              expected.slashed
+            );
+          });
           test('Human-readable', () => {
             expect(
               formatDateTimeWithOffset({
diff --git a/src/internal/utils/date-time/format-date-time-with-offset.ts b/src/internal/utils/date-time/format-date-time-with-offset.ts
index 33f920c462..8e9ca04126 100644
--- a/src/internal/utils/date-time/format-date-time-with-offset.ts
+++ b/src/internal/utils/date-time/format-date-time-with-offset.ts
@@ -25,6 +25,10 @@ export function formatDateTimeWithOffset({
     case 'long-localized': {
       return formatDateLocalized({ date, hideTimeOffset, isDateOnly, isMonthOnly, locale, timeOffset });
     }
+    case 'slashed': {
+      const formatted = formatDateIso({ date, hideTimeOffset, isDateOnly, isMonthOnly, timeOffset }).split('T');
+      return `${formatted[0].split('-').join('/')}${formatted[1] ? `T${formatted[1]}` : ''}`;
+    }
     default: {
       return formatDateIso({ date, hideTimeOffset, isDateOnly, isMonthOnly, timeOffset });
     }

From a0faa2dcb49d6ce87f26fbf62a8d441c82f5ac60 Mon Sep 17 00:00:00 2001
From: Georgii Lobko <47106899+georgylobko@users.noreply.github.com>
Date: Tue, 16 Sep 2025 15:48:30 +0200
Subject: [PATCH 23/32] feat: Add a new whenAppLayoutReady to the plugin api
 (#3863)

---
 package.json                                  |  2 +-
 .../runtime-drawers-widgetized.test.tsx       | 21 ++++++++++++++++++-
 src/internal/plugins/widget.ts                |  2 +-
 src/internal/plugins/widget/internal.ts       | 16 ++++++++++++++
 4 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index 5b18fa5302..51b8032459 100644
--- a/package.json
+++ b/package.json
@@ -166,7 +166,7 @@
     {
       "path": "lib/components/internal/widget-exports.js",
       "brotli": false,
-      "limit": "890 kB",
+      "limit": "891 kB",
       "ignore": "react-dom"
     }
   ],
diff --git a/src/app-layout/__tests__/runtime-drawers-widgetized.test.tsx b/src/app-layout/__tests__/runtime-drawers-widgetized.test.tsx
index dcc32b9095..7df9ba1aa2 100644
--- a/src/app-layout/__tests__/runtime-drawers-widgetized.test.tsx
+++ b/src/app-layout/__tests__/runtime-drawers-widgetized.test.tsx
@@ -48,17 +48,36 @@ describeEachAppLayout({ themes: ['refresh-toolbar'] }, ({ size }) => {
     expect(globalDrawersWrapper.findDrawerById(drawerDefaults.id)!.isActive()).toBe(true);
   });
 
-  test('isAppLayoutReady returns true when app layout is ready', () => {
+  test('isAppLayoutReady returns true when app layout is ready', async () => {
     expect(awsuiWidgetPlugins.isAppLayoutReady()).toBe(false);
     const { rerender } = renderComponent(<AppLayout />);
 
     expect(awsuiWidgetPlugins.isAppLayoutReady()).toBe(true);
+    await expect(awsuiWidgetPlugins.whenAppLayoutReady()).resolves.toBe(undefined);
 
     rerender(<></>);
 
     expect(awsuiWidgetPlugins.isAppLayoutReady()).toBe(false);
   });
 
+  test('whenAppLayoutReady resolves when app layout is ready', async () => {
+    const readyPromise = awsuiWidgetPlugins.whenAppLayoutReady();
+
+    let isResolved = false;
+    readyPromise.then(() => {
+      isResolved = true;
+    });
+
+    expect(isResolved).toBe(false);
+
+    const { rerender } = renderComponent(<AppLayout />);
+
+    rerender(<></>);
+
+    await readyPromise;
+    expect(isResolved).toBe(true);
+  });
+
   test('adds ai drawer to an already rendered component', () => {
     const { globalDrawersWrapper } = renderComponent(<AppLayout />);
     expect(globalDrawersWrapper.findAiDrawerTrigger()).toBeFalsy();
diff --git a/src/internal/plugins/widget.ts b/src/internal/plugins/widget.ts
index a5456b944d..252e44c7b2 100644
--- a/src/internal/plugins/widget.ts
+++ b/src/internal/plugins/widget.ts
@@ -1,4 +1,4 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 export * from './widget/interfaces';
-export { registerLeftDrawer, updateDrawer, isAppLayoutReady } from './widget/internal';
+export { registerLeftDrawer, updateDrawer, isAppLayoutReady, whenAppLayoutReady } from './widget/internal';
diff --git a/src/internal/plugins/widget/internal.ts b/src/internal/plugins/widget/internal.ts
index 77efb3746b..a70122c207 100644
--- a/src/internal/plugins/widget/internal.ts
+++ b/src/internal/plugins/widget/internal.ts
@@ -6,10 +6,12 @@ import { AppLayoutMessage, AppLayoutUpdateMessage, DrawerPayload, RegisterDrawer
 
 const storageKeyMessageHandler = Symbol.for('awsui-widget-api-message-handler');
 const storageKeyInitialMessages = Symbol.for('awsui-widget-api-initial-messages');
+const storageKeyReadyDeferCallbacks = Symbol.for('awsui-widget-api-ready-defer');
 
 interface WindowWithApi extends Window {
   [storageKeyMessageHandler]: AppLayoutHandler | undefined;
   [storageKeyInitialMessages]: Array<RegisterDrawerMessage> | undefined;
+  [storageKeyReadyDeferCallbacks]: Array<(value?: unknown) => void> | undefined;
 }
 
 type AppLayoutHandler = (event: AppLayoutMessage) => void;
@@ -33,6 +35,8 @@ export function registerAppLayoutHandler(handler: AppLayoutHandler) {
     reportRuntimeApiWarning('AppLayoutWidget', 'Double registration attempt, the old handler will be overridden');
   }
   win[storageKeyMessageHandler] = handler;
+  win[storageKeyReadyDeferCallbacks]?.forEach(fn => fn());
+  win[storageKeyReadyDeferCallbacks] = [];
   return () => {
     win[storageKeyMessageHandler] = undefined;
   };
@@ -49,6 +53,18 @@ export function isAppLayoutReady() {
   return !!getAppLayoutMessageHandler();
 }
 
+/**
+ * Returns a promise that resolves once the app layout has loaded
+ */
+export function whenAppLayoutReady() {
+  if (isAppLayoutReady()) {
+    return Promise.resolve();
+  }
+  const win = getWindow();
+  win[storageKeyReadyDeferCallbacks] = win[storageKeyReadyDeferCallbacks] ?? [];
+  return new Promise(resolve => win[storageKeyReadyDeferCallbacks]?.push(resolve));
+}
+
 /**
  * Registers a new runtime drawer to app layout
  * @param drawer

From 0e1280c6e5e35700e2f926aca565a9fb132ae822 Mon Sep 17 00:00:00 2001
From: Georgii Lobko <47106899+georgylobko@users.noreply.github.com>
Date: Tue, 16 Sep 2025 19:28:47 +0200
Subject: [PATCH 24/32] chore: Increase AI drawer min size (#3864)

---
 .../widget-contract-old.test.tsx.snap         | 32 +++++++++----------
 ...get-contract-split-panel-old.test.tsx.snap | 20 ++++++------
 .../__tests__/runtime-drawers.test.tsx        |  6 ++--
 src/app-layout/utils/use-ai-drawer.ts         |  2 +-
 4 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/src/app-layout/__tests__/__snapshots__/widget-contract-old.test.tsx.snap b/src/app-layout/__tests__/__snapshots__/widget-contract-old.test.tsx.snap
index dfe8fdb578..776ae9c761 100644
--- a/src/app-layout/__tests__/__snapshots__/widget-contract-old.test.tsx.snap
+++ b/src/app-layout/__tests__/__snapshots__/widget-contract-old.test.tsx.snap
@@ -85,7 +85,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -278,7 +278,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -431,7 +431,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -615,7 +615,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -768,7 +768,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -930,7 +930,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <div>
@@ -1132,7 +1132,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <div>
@@ -1291,7 +1291,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <div>
@@ -1453,7 +1453,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <div>
@@ -1645,7 +1645,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <div>
@@ -1804,7 +1804,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <div>
@@ -1980,7 +1980,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -2191,7 +2191,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -2360,7 +2360,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -2560,7 +2560,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -2729,7 +2729,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
diff --git a/src/app-layout/__tests__/__snapshots__/widget-contract-split-panel-old.test.tsx.snap b/src/app-layout/__tests__/__snapshots__/widget-contract-split-panel-old.test.tsx.snap
index 5d86e0a1db..7d29d07a3b 100644
--- a/src/app-layout/__tests__/__snapshots__/widget-contract-split-panel-old.test.tsx.snap
+++ b/src/app-layout/__tests__/__snapshots__/widget-contract-split-panel-old.test.tsx.snap
@@ -85,7 +85,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -278,7 +278,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -431,7 +431,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -622,7 +622,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -775,7 +775,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -933,7 +933,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -1126,7 +1126,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -1279,7 +1279,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -1469,7 +1469,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
@@ -1622,7 +1622,7 @@ Map {
       "maxAiDrawerSize": Infinity,
       "maxDrawerSize": Infinity,
       "maxGlobalDrawersSizes": {},
-      "minAiDrawerSize": 290,
+      "minAiDrawerSize": 400,
       "minDrawerSize": 290,
       "minGlobalDrawersSizes": {},
       "navigation": <React.Fragment />,
diff --git a/src/app-layout/__tests__/runtime-drawers.test.tsx b/src/app-layout/__tests__/runtime-drawers.test.tsx
index 45ddfdbb06..0e464510a9 100644
--- a/src/app-layout/__tests__/runtime-drawers.test.tsx
+++ b/src/app-layout/__tests__/runtime-drawers.test.tsx
@@ -1796,20 +1796,20 @@ describe('toolbar mode only features', () => {
       await waitFor(() => {
         expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test')).toEqual('290px');
         expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test1')).toEqual('290px');
-        expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test2')).toEqual('290px');
+        expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test2')).toEqual('400px');
       });
 
       awsuiPlugins.appLayout.resizeDrawer('test', 800);
 
       expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test')).toEqual('800px');
       expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test1')).toEqual('290px');
-      expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test2')).toEqual('290px');
+      expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test2')).toEqual('400px');
 
       awsuiPlugins.appLayout.resizeDrawer('test1', 801);
 
       expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test')).toEqual('800px');
       expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test1')).toEqual('801px');
-      expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test2')).toEqual('290px');
+      expect(getGlobalDrawerWidth(globalDrawersWrapper, 'test2')).toEqual('400px');
 
       awsuiWidgetPlugins.updateDrawer({ type: 'resizeDrawer', payload: { id: 'test2', size: 600 } });
 
diff --git a/src/app-layout/utils/use-ai-drawer.ts b/src/app-layout/utils/use-ai-drawer.ts
index 0dae462536..7945db2fd6 100644
--- a/src/app-layout/utils/use-ai-drawer.ts
+++ b/src/app-layout/utils/use-ai-drawer.ts
@@ -83,7 +83,7 @@ function useRuntimeAiDrawer(
   return aiDrawer && mapRuntimeConfigToAiDrawer(aiDrawer);
 }
 
-export const MIN_DRAWER_SIZE = 290;
+const MIN_DRAWER_SIZE = 400;
 
 interface UseDrawersProps {
   isEnabled: boolean;

From f856831b287d3582ec314043f2321c48046b0cf2 Mon Sep 17 00:00:00 2001
From: Boris Serdiuk <serdiuk@amazon.com>
Date: Wed, 17 Sep 2025 10:52:17 +0200
Subject: [PATCH 25/32] fix: Table scrollable detection (#3871)

---
 src/table/internal.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/table/internal.tsx b/src/table/internal.tsx
index af0e8c1c6e..a55bac76ab 100644
--- a/src/table/internal.tsx
+++ b/src/table/internal.tsx
@@ -179,11 +179,11 @@ const InternalTable = React.forwardRef(
       getExpandableItemProps,
     });
 
-    const [containerWidth, wrapperMeasureRef] = useContainerQuery<number>(rect => rect.contentBoxWidth);
+    const [containerWidth, wrapperMeasureRef] = useContainerQuery<number>(rect => rect.borderBoxWidth);
     const wrapperMeasureRefObject = useRef(null);
     const wrapperMeasureMergedRef = useMergeRefs(wrapperMeasureRef, wrapperMeasureRefObject);
 
-    const [tableWidth, tableMeasureRef] = useContainerQuery<number>(rect => rect.contentBoxWidth);
+    const [tableWidth, tableMeasureRef] = useContainerQuery<number>(rect => rect.borderBoxWidth);
     const tableRefObject = useRef(null);
 
     const secondaryWrapperRef = React.useRef<HTMLDivElement>(null);

From 8d61a8ed3e1cdc42cae8191b21b3bf0c1ff202cb Mon Sep 17 00:00:00 2001
From: Georgii Lobko <47106899+georgylobko@users.noreply.github.com>
Date: Wed, 17 Sep 2025 11:10:31 +0200
Subject: [PATCH 26/32] fix: Drawers triggers size (#3854)

---
 src/app-layout/visual-refresh-toolbar/toolbar/styles.scss | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/app-layout/visual-refresh-toolbar/toolbar/styles.scss b/src/app-layout/visual-refresh-toolbar/toolbar/styles.scss
index 37ce2d8f90..be71d1b835 100644
--- a/src/app-layout/visual-refresh-toolbar/toolbar/styles.scss
+++ b/src/app-layout/visual-refresh-toolbar/toolbar/styles.scss
@@ -117,7 +117,7 @@ $toolbar-height: 42px;
     align-items: center;
     display: grid;
     inline-size: 100%;
-    grid-template-columns: min-content min-content minmax(0, 3fr) minmax(auto, 1fr);
+    grid-template-columns: min-content min-content 1fr min-content;
     grid-template-rows: 1fr;
 
     @include theming.dark-mode-only {
@@ -150,6 +150,9 @@ $toolbar-height: 42px;
       display: flex;
       justify-content: flex-end;
       block-size: 100%;
+      min-inline-size: 0;
+      flex-shrink: 0;
+      inline-size: clamp(200px, 25vw, 400px);
     }
   }
 }

From 19650ab141ed5d75252cd1a381bbe80e657a10c3 Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Mon, 8 Sep 2025 12:18:22 +0200
Subject: [PATCH 27/32] chore: Increase size limit

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 51b8032459..cea7162bb3 100644
--- a/package.json
+++ b/package.json
@@ -166,7 +166,7 @@
     {
       "path": "lib/components/internal/widget-exports.js",
       "brotli": false,
-      "limit": "891 kB",
+      "limit": "892 kB",
       "ignore": "react-dom"
     }
   ],

From b3ea6bfb9c8995d26aa3b3bd1351089134392389 Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Wed, 17 Sep 2025 12:26:36 +0200
Subject: [PATCH 28/32] chore: Adjust background opacity for flashbar

---
 style-dictionary/visual-refresh/contexts/flashbar.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/style-dictionary/visual-refresh/contexts/flashbar.ts b/style-dictionary/visual-refresh/contexts/flashbar.ts
index 0cbda207ae..f333f6ffc1 100644
--- a/style-dictionary/visual-refresh/contexts/flashbar.ts
+++ b/style-dictionary/visual-refresh/contexts/flashbar.ts
@@ -24,7 +24,7 @@ export const baseTokens: StyleDictionary.ColorsDictionary = {
   colorBorderDividerDefault: '{colorGrey100}',
   colorTextTutorialHotspotDefault: '{colorGrey300}',
   colorTextTutorialHotspotHover: '{colorGrey100}',
-  colorBackgroundInlineCode: 'rgba(0, 0, 0, 0.15)',
+  colorBackgroundInlineCode: 'rgba(0, 0, 0, 0.2)',
 };
 
 const expandedTokens: StyleDictionary.ExpandedColorScopeDictionary = expandColorDictionary(

From 552662ef09df3123ccf92d956db08d5bc5410278 Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Wed, 17 Sep 2025 13:44:24 +0200
Subject: [PATCH 29/32] chore: Update snapshot test and increase size limit

---
 package.json                                    | 2 +-
 src/__integ__/__snapshots__/themes.test.ts.snap | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index cea7162bb3..8536dd8944 100644
--- a/package.json
+++ b/package.json
@@ -166,7 +166,7 @@
     {
       "path": "lib/components/internal/widget-exports.js",
       "brotli": false,
-      "limit": "892 kB",
+      "limit": "893 kB",
       "ignore": "react-dom"
     }
   ],
diff --git a/src/__integ__/__snapshots__/themes.test.ts.snap b/src/__integ__/__snapshots__/themes.test.ts.snap
index 5d0da4ffd7..2b9e640471 100644
--- a/src/__integ__/__snapshots__/themes.test.ts.snap
+++ b/src/__integ__/__snapshots__/themes.test.ts.snap
@@ -86,6 +86,7 @@ exports[`CSS Custom Properties match previous snapshot for mode "compact" 1`] =
   "color-background-dropdown-item-hover": "#f2f3f3",
   "color-background-dropdown-item-selected": "#f1faff",
   "color-background-home-header": "#000000",
+  "color-background-inline-code": "rgba(0, 0, 0, 0.1)",
   "color-background-input-default": "#ffffff",
   "color-background-input-disabled": "#eaeded",
   "color-background-item-selected": "#f1faff",
@@ -764,6 +765,7 @@ exports[`CSS Custom Properties match previous snapshot for mode "dark" 1`] = `
   "color-background-dropdown-item-hover": "#414750",
   "color-background-dropdown-item-selected": "#12293b",
   "color-background-home-header": "#000000",
+  "color-background-inline-code": "rgba(255, 255, 255, 0.1)",
   "color-background-input-default": "#1a2029",
   "color-background-input-disabled": "#414750",
   "color-background-item-selected": "#12293b",
@@ -1442,6 +1444,7 @@ exports[`CSS Custom Properties match previous snapshot for mode "light" 1`] = `
   "color-background-dropdown-item-hover": "#f2f3f3",
   "color-background-dropdown-item-selected": "#f1faff",
   "color-background-home-header": "#000000",
+  "color-background-inline-code": "rgba(0, 0, 0, 0.1)",
   "color-background-input-default": "#ffffff",
   "color-background-input-disabled": "#eaeded",
   "color-background-item-selected": "#f1faff",
@@ -2120,6 +2123,7 @@ exports[`CSS Custom Properties match previous snapshot for mode "reduced-motion"
   "color-background-dropdown-item-hover": "#f2f3f3",
   "color-background-dropdown-item-selected": "#f1faff",
   "color-background-home-header": "#000000",
+  "color-background-inline-code": "rgba(0, 0, 0, 0.1)",
   "color-background-input-default": "#ffffff",
   "color-background-input-disabled": "#eaeded",
   "color-background-item-selected": "#f1faff",
@@ -2798,6 +2802,7 @@ exports[`CSS Custom Properties match previous snapshot for mode "visual-refresh"
   "color-background-dropdown-item-hover": "#f3f3f7",
   "color-background-dropdown-item-selected": "#f0fbff",
   "color-background-home-header": "#0f141a",
+  "color-background-inline-code": "rgba(0, 0, 0, 0.1)",
   "color-background-input-default": "#ffffff",
   "color-background-input-disabled": "#ebebf0",
   "color-background-item-selected": "#f0fbff",
@@ -3476,6 +3481,7 @@ exports[`CSS Custom Properties match previous snapshot for mode "visual-refresh-
   "color-background-dropdown-item-hover": "#f3f3f7",
   "color-background-dropdown-item-selected": "#f0fbff",
   "color-background-home-header": "#0f141a",
+  "color-background-inline-code": "rgba(0, 0, 0, 0.1)",
   "color-background-input-default": "#ffffff",
   "color-background-input-disabled": "#ebebf0",
   "color-background-item-selected": "#f0fbff",
@@ -4154,6 +4160,7 @@ exports[`CSS Custom Properties match previous snapshot for mode "visual-refresh-
   "color-background-dropdown-item-hover": "#131920",
   "color-background-dropdown-item-selected": "#001129",
   "color-background-home-header": "#0f141a",
+  "color-background-inline-code": "rgba(255, 255, 255, 0.1)",
   "color-background-input-default": "#0f141a",
   "color-background-input-disabled": "#1b232d",
   "color-background-item-selected": "#001129",
@@ -4832,6 +4839,7 @@ exports[`CSS Custom Properties match previous snapshot for mode "visual-refresh-
   "color-background-dropdown-item-hover": "#131920",
   "color-background-dropdown-item-selected": "#001129",
   "color-background-home-header": "#0f141a",
+  "color-background-inline-code": "rgba(255, 255, 255, 0.1)",
   "color-background-input-default": "#161d26",
   "color-background-input-disabled": "#1b232d",
   "color-background-item-selected": "#001129",

From 7e0c803a38b8e51d0a053ba2607bdff9d8aa1c29 Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Wed, 17 Sep 2025 16:27:55 +0200
Subject: [PATCH 30/32] chore: Ignore color contrast check

---
 src/__a11y__/a11y-page-object.ts | 30 +++++++++++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/src/__a11y__/a11y-page-object.ts b/src/__a11y__/a11y-page-object.ts
index f75251b3ca..2fa18ea499 100644
--- a/src/__a11y__/a11y-page-object.ts
+++ b/src/__a11y__/a11y-page-object.ts
@@ -89,7 +89,9 @@ export default class A11yPageObject extends BasePageObject {
   public async assertNoAxeViolations() {
     const currentUrl = await this.browser.getUrl();
     const result = await this.getAxeResults();
-    const violations = result.violations.filter(violation => landmarkViolationFilter(violation, currentUrl));
+    const violations = result.violations
+      .filter(violation => landmarkViolationFilter(violation, currentUrl))
+      .filter(violation => inlineCodeInFlashbarFilter(violation));
     const incomplete = result.incomplete.filter(ariaLevelViolationsFilter);
 
     expect(violations).toHaveLength(0);
@@ -120,3 +122,29 @@ function landmarkViolationFilter(violation: Axe.Result, currentUrl: string) {
       violation.id !== 'landmark-no-duplicate-main')
   );
 }
+
+// Filter out color contrast violations for Box awsui-inline-code variant within Flashbar components.
+// It improves contrast by adding a darker background overlay, which makes the color contrast greater.
+// However because of its semi-transparent style `colorBackgroundInlineCode: 'rgba(0, 0, 0, 0.2)'`,
+// it causes insufficient color contrast based on how axe-core caluculates color contrast.
+function inlineCodeInFlashbarFilter(violation: Axe.Result) {
+  // Only filter color-contrast violations
+  if (violation.id !== 'color-contrast') {
+    return true;
+  }
+
+  // Check if any of the violation nodes are awsui-inline-code boxes within flashbar components
+  const hasInlineCodeInFlashbar = violation.nodes.some(node => {
+    // Check if the node HTML contains the inline-code variant class
+    const hasInlineCodeClass = node.html.includes('inline-code-variant');
+
+    // Check if the node is within a flashbar component (contains flash class in ancestors)
+    const isInFlashbar =
+      node.html.includes('flash') || (node.ancestry && node.ancestry.some(ancestor => ancestor.includes('flash')));
+
+    return hasInlineCodeClass && isInFlashbar;
+  });
+
+  // Return false to filter out (exclude) violations that match our criteria
+  return !hasInlineCodeInFlashbar;
+}

From bcf950237a5a344883ac63332828622dae3a4403 Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Wed, 17 Sep 2025 16:58:16 +0200
Subject: [PATCH 31/32] chore: Bring original a11y test back and changed css to
 background-color

---
 src/__a11y__/a11y-page-object.ts | 30 +-----------------------------
 src/box/text.scss                |  2 +-
 2 files changed, 2 insertions(+), 30 deletions(-)

diff --git a/src/__a11y__/a11y-page-object.ts b/src/__a11y__/a11y-page-object.ts
index 2fa18ea499..f75251b3ca 100644
--- a/src/__a11y__/a11y-page-object.ts
+++ b/src/__a11y__/a11y-page-object.ts
@@ -89,9 +89,7 @@ export default class A11yPageObject extends BasePageObject {
   public async assertNoAxeViolations() {
     const currentUrl = await this.browser.getUrl();
     const result = await this.getAxeResults();
-    const violations = result.violations
-      .filter(violation => landmarkViolationFilter(violation, currentUrl))
-      .filter(violation => inlineCodeInFlashbarFilter(violation));
+    const violations = result.violations.filter(violation => landmarkViolationFilter(violation, currentUrl));
     const incomplete = result.incomplete.filter(ariaLevelViolationsFilter);
 
     expect(violations).toHaveLength(0);
@@ -122,29 +120,3 @@ function landmarkViolationFilter(violation: Axe.Result, currentUrl: string) {
       violation.id !== 'landmark-no-duplicate-main')
   );
 }
-
-// Filter out color contrast violations for Box awsui-inline-code variant within Flashbar components.
-// It improves contrast by adding a darker background overlay, which makes the color contrast greater.
-// However because of its semi-transparent style `colorBackgroundInlineCode: 'rgba(0, 0, 0, 0.2)'`,
-// it causes insufficient color contrast based on how axe-core caluculates color contrast.
-function inlineCodeInFlashbarFilter(violation: Axe.Result) {
-  // Only filter color-contrast violations
-  if (violation.id !== 'color-contrast') {
-    return true;
-  }
-
-  // Check if any of the violation nodes are awsui-inline-code boxes within flashbar components
-  const hasInlineCodeInFlashbar = violation.nodes.some(node => {
-    // Check if the node HTML contains the inline-code variant class
-    const hasInlineCodeClass = node.html.includes('inline-code-variant');
-
-    // Check if the node is within a flashbar component (contains flash class in ancestors)
-    const isInFlashbar =
-      node.html.includes('flash') || (node.ancestry && node.ancestry.some(ancestor => ancestor.includes('flash')));
-
-    return hasInlineCodeClass && isInFlashbar;
-  });
-
-  // Return false to filter out (exclude) violations that match our criteria
-  return !hasInlineCodeInFlashbar;
-}
diff --git a/src/box/text.scss b/src/box/text.scss
index 448068784c..798b480b88 100644
--- a/src/box/text.scss
+++ b/src/box/text.scss
@@ -60,7 +60,7 @@
       border-start-end-radius: awsui.$space-static-xxs;
       border-end-start-radius: awsui.$space-static-xxs;
       border-end-end-radius: awsui.$space-static-xxs;
-      background: awsui.$color-background-inline-code;
+      background-color: awsui.$color-background-inline-code;
       padding-block: awsui.$space-static-xxxs;
       padding-inline: awsui.$space-static-xxs;
     }

From bc21969fffd018feb35b1cd9c6dbe2807f72baa1 Mon Sep 17 00:00:00 2001
From: at-susie <ienakaai@amazon.de>
Date: Mon, 29 Sep 2025 11:16:42 +0200
Subject: [PATCH 32/32] chore: Updte Box test code

---
 src/box/__tests__/box.test.tsx | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/box/__tests__/box.test.tsx b/src/box/__tests__/box.test.tsx
index c8774743a3..ed7c79cce7 100644
--- a/src/box/__tests__/box.test.tsx
+++ b/src/box/__tests__/box.test.tsx
@@ -59,6 +59,10 @@ describe('Box', () => {
       const boxWrapper = renderBox({ variant: 'awsui-value-large' });
       expect(boxWrapper.getElement().tagName).toBe('SPAN');
     });
+    test('uses code as tag name when set to awsui-inline-code', () => {
+      const boxWrapper = renderBox({ variant: 'awsui-inline-code' });
+      expect(boxWrapper.getElement().tagName).toBe('CODE');
+    });
   });
   describe('tagOverride property', () => {
     const tagOverrides = [