diff --git a/website/docs/core/trex_format.md b/website/docs/core/trex_format.md
index cdaa8932..116fd5d5 100644
--- a/website/docs/core/trex_format.md
+++ b/website/docs/core/trex_format.md
@@ -87,7 +87,7 @@ dashboard.addEventListener(tableau.TableauEventType.WorkbookFormattingChanged, (
For more information about using event listeners, see [Events and Event Handling](./trex_events.md).
-## What's Next
+## What's Next?
* To see a working sample dashboard extension that uses workbook formatting, see the JavaScript [Formatting](https://github.com/tableau/extensions-api/tree/main/Samples/Dashboard/Formatting) sample in the Samples folder, or the TypeScript [Formatting](https://github.com/tableau/extensions-api/tree/main/Samples-Typescript/Dashboard/Formatting) sample in the Samples-Typescript folder.
diff --git a/website/docs/dashext/trex_create.md b/website/docs/dashext/trex_create.md
index 39469cd3..563c9dfa 100644
--- a/website/docs/dashext/trex_create.md
+++ b/website/docs/dashext/trex_create.md
@@ -177,7 +177,7 @@ After you have created the manifest file (`.trex`) and have hosted your web app
- If not, and you see a 404 error, verify that you specified the correct URL to serve the page in the `.trex` file.
- - Tableau parses the `.trex` file when you add the extension to the dashboard. If you make changes to the `.trex` file after you have added it to the dashboard, you need to remove the extension and re-add it. See [What Happens When you Reload an Extension](../debug/trex_reload.md)
+ - Tableau parses the `.trex` file when you add the extension to the dashboard. If you make changes to the `.trex` file after you have added it to the dashboard, you need to remove the extension and re-add it. See [What Happens When you Reload an Extension?](../debug/trex_reload.md)
---
diff --git a/website/docs/dashext/trex_overview.md b/website/docs/dashext/trex_overview.md
index 8cf6137b..31fef920 100644
--- a/website/docs/dashext/trex_overview.md
+++ b/website/docs/dashext/trex_overview.md
@@ -1,5 +1,5 @@
---
-title: What is a Tableau Dashboard Extension
+title: What is a Tableau Dashboard Extension?
description: What is a dashboard extension and what can you do with it
---
diff --git a/website/docs/dataapps/delet-this-trex_dataapp_getstarted_extension_packaging.md b/website/docs/dataapps/delet-this-trex_dataapp_getstarted_extension_packaging.md
new file mode 100644
index 00000000..09a68521
--- /dev/null
+++ b/website/docs/dataapps/delet-this-trex_dataapp_getstarted_extension_packaging.md
@@ -0,0 +1,49 @@
+---
+title: Get Started with Data Apps — Extension Packaging
+description: Package and publish a working Viz or Dashboard Extension as a Tableau data app.
+tags: [Getting started]
+---
+
+The data apps beta is available only on Tableau Cloud.
+
+Start with a working Viz or Dashboard Extension. To create one, follow [Get Started with Viz Extensions](../vizext/trex_viz_getstarted.md) or [Get Started with Dashboard Extensions](../dashext/trex_getstarted.md).
+
+A data app combines your custom interface with Tableau hosting and runtime access to Tableau data. You package the extension's web resources with a workbook so Tableau can host and serve them. For more about these concepts, see [What are Tableau data apps?](./trex_dataapp_overview.md).
+
+## Prepare your Tableau environment
+
+Confirm that your environment meets the [data apps beta requirements](../installation.md#requirements-for-using-extensions-in-tableau). You need permission to access the app's data and publish the workbook to the intended location.
+
+Work with your administrator to enable the required site settings and review the app's external origins and Tableau REST API access. See [Manage data apps](./trex_dataapp_manage.md) for site preparation, access review, and publishing guidance.
+
+## Use the Data Apps API methods
+
+Three methods added to the Extensions API for this release support data apps:
+
+| Method | Purpose |
+| --- | --- |
+| `queryAsync()` | Gets data from the configured data source asynchronously. |
+| `readMetadata()` | Gets a data source's metadata. |
+| `fetch()` | Makes a curated set of Tableau REST API requests, subject to the site's allowed API access and the viewing user's permissions. |
+
+Use these methods in your working Viz or Dashboard Extension as needed for its data and workflow. For an overview, see [Extensions API methods for data apps](./trex_dataapp_overview.md#extensions-api-methods-for-data-apps).
+
+## Review security and dependencies
+
+Review the working extension's code, libraries, data queries, and external services before packaging it. Request only the access the app needs, and keep secrets and fixed copies of sensitive data out of its front-end resources.
+
+See [data app security](./trex_dataapp_security.md) for guidance on data permissions, hosted code, external origins, and Tableau API access.
+
+## Package and publish
+
+Include the extension manifest, entry page, Extensions API library, and all required JavaScript, CSS, images, and other resources in the workbook package. Check that the entry page's resource paths resolve inside the package. See [Data App Details](./trex_dataapp_details.md) for the package layout and manifest examples.
+
+Use the packaging workflow available in your beta environment, then publish the packaged workbook to a location where the intended viewers have access. Tableau serves the packaged front-end resources; any external services the app uses still need to be available and approved.
+
+Follow the review and publishing guidance in [Manage data apps](./trex_dataapp_manage.md).
+
+## Verify the published app
+
+Open the published app as an intended viewer. Confirm that its packaged resources load, its controls work, and its queries respect the viewer's data access. Test loading, empty, and error states as well.
+
+Use the checks in [data app security](./trex_dataapp_security.md#test-security-before-sharing) before sharing the app.
diff --git a/website/docs/dataapps/index.md b/website/docs/dataapps/index.md
new file mode 100644
index 00000000..7ee1b70f
--- /dev/null
+++ b/website/docs/dataapps/index.md
@@ -0,0 +1,12 @@
+# (Cloud-only Beta) Data Apps
+
+The data apps beta is available only on Tableau Cloud.
+Build custom analytical applications on governed Tableau data and share them through Tableau. A data app combines a custom web interface with Tableau data access and hosting. Its front-end resources are embedded in a packaged workbook and served by Tableau.
+
+Start with the overview to understand the concepts, then follow the getting started and creation guides.
+
+```mdx-code-block
+import DocCardList from '@theme/DocCardList';
+
+
+```
diff --git a/website/docs/dataapps/trex_dataapp_admin_security.md b/website/docs/dataapps/trex_dataapp_admin_security.md
new file mode 100644
index 00000000..e3598aeb
--- /dev/null
+++ b/website/docs/dataapps/trex_dataapp_admin_security.md
@@ -0,0 +1,12 @@
+---
+title: Administration and Security for Data Apps
+description: Find administration and security guidance for Tableau data apps.
+sidebar_label: Administration and Security
+---
+
+The data apps beta is available only on Tableau Cloud.
+
+Administration and security guidance is available on two pages:
+
+- [Manage data apps](./trex_dataapp_manage.md) covers site preparation, access review, publishing, and ongoing administration.
+- [Data app security](./trex_dataapp_security.md) covers data permissions, hosted code, external origins, and Tableau REST API access.
diff --git a/website/docs/dataapps/trex_dataapp_details.md b/website/docs/dataapps/trex_dataapp_details.md
new file mode 100644
index 00000000..1c7049b1
--- /dev/null
+++ b/website/docs/dataapps/trex_dataapp_details.md
@@ -0,0 +1,245 @@
+---
+title: Data App Details
+description: The workbook, manifests, web resources, data connections, and runtime access that make up a Tableau data app.
+---
+
+The data apps beta is available only on Tableau Cloud.
+
+A data app is a Dashboard or Viz Extension whose web resources are packaged with a Tableau workbook. The workbook places the interface and connects its data sources; the package supplies its manifests and front-end code. Tableau serves the bundled resources when a viewer opens the published workbook. Application code runs in the viewer's browser and queries Tableau at runtime.
+
+The examples below describe a worksheet-based app named **Regional Sales**, using a published data source named **Sales** with a **Region** field. The same package model supports Dashboard Extensions, with the corresponding dashboard placement and manifest.
+
+## Files and package structure
+
+An unpacked app has this structure:
+
+```text
+Regional Sales/
+├── Regional Sales.twb
+└── Packages/
+ └── com.example.regional-sales/
+ ├── manifest.json
+ ├── extensions/
+ │ └── data-app.trex
+ └── content/
+ ├── index.html
+ └── src/
+ ├── app.js
+ ├── styles.css
+ └── tableau.extensions.1.latest.js
+```
+
+| Element | Responsibility |
+| --- | --- |
+| `.twb` workbook | Contains the worksheet or dashboard, the extension instance and its settings, and the data-source connections. |
+| `manifest.json` | Identifies the package and its version, display name, and author. |
+| `.trex` extension manifest | Declares the extension's identity, placement type, entry page, minimum API version, and permissions. |
+| `content/` | Contains the HTML entry page and all bundled scripts, styles, images, fonts, and other assets. |
+| Extensions API library | Initializes the extension's connection to Tableau and exposes supported runtime APIs. |
+
+The published `.twbx` is a ZIP archive with the `.twb` and `Packages/` at its root. The enclosing `Regional Sales/` directory is not an extra archive level. Resource paths must resolve inside the package; files on a developer's machine do not become available to viewers unless bundled.
+
+## Package identity
+
+`Packages/com.example.regional-sales/manifest.json` contains the package's display metadata:
+
+```json
+{
+ "id": "com.example.regional-sales",
+ "version": "1.0.0",
+ "name": "Regional Sales",
+ "author": "Example Company"
+}
+```
+
+In this single-extension example, the package directory, package ID, and extension ID use the same unique reverse-domain identifier. The package and extension versions are `1.0.0`. A new distributed version needs consistent updated metadata. These fields describe the supplied example format; additional capabilities depend on the supported beta package schema.
+
+## Extension manifest and entry page
+
+`extensions/data-app.trex` describes the worksheet integration:
+
+```xml
+
+
+
+ en_US
+
+ Regions from a published Tableau data source.
+
+ 1.11
+
+ index.html
+
+ iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=
+
+ full data
+
+
+ Data
+
+ discrete-dimension
+ continuous-dimension
+ discrete-measure
+ continuous-measure
+
+
+
+
+
+
+
+ Regional Sales
+
+
+
+```
+
+`index.html` resolves under the package's `content/` directory. The icon is a small Base64 placeholder. The `field` encoding defines a Data tile on the Marks card; `50` is this example's field count, not a platform limit. The `full data` declaration does not grant additional Tableau data permissions.
+
+The supplied apps declare minimum API version `1.11`. This is an Extensions API version, not a Tableau product version or a guarantee that every data app API is available. The library and Tableau environment must support the methods the app uses.
+
+For dashboard placement, the `.trex` uses the [Dashboard Extension manifest](../dashext/trex_manifest.md) and the workbook hosts the extension in a dashboard zone. The example above uses the [Viz Extension manifest](../vizext/trex_viz_manifest.md) and a worksheet pane.
+
+## Workbook integration
+
+A package directory alone does not place the app in a view. The `.twb` contains an extension instance, a referenced extension manifest, and the app's data-source connection. The following XML fragments show the relationships inside a worksheet workbook; they are parts of the workbook, not standalone `.twb` files.
+
+### Extension instance
+
+The app's worksheet contains this pane under `worksheet/table/panes`:
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+```
+
+The `tableaulocalext:///` URL addresses the package's entry page. `add-in-id` and `extension-version` match the extension manifest. Instance and encoding identifiers must be unique for the instances they identify. The custom encoding refers to both the manifest's `field` encoding and the worksheet's Region column instance.
+
+Under `workbook/referenced-extensions`, the corresponding `referenced-extension` contains a copy of the extension manifest and a `referenced-views` element:
+
+```xml
+
+
+
+```
+
+In the workbook's manifest copy, the display name is resolved to `Regional Sales` and the source URL is the full `tableaulocalext:///com.example.regional-sales/content/index.html` URL. The worksheet's `name`, its `window` name under `workbook/windows`, and this `viewId` all identify **Regional Sales**.
+
+### Published data-source connection
+
+The workbook's top-level `datasources` contains the published source. This example uses site content URL `sales-site`, published data-source content URL `Sales`, and a placeholder Tableau Cloud host:
+
+```xml
+
+
+
+
+
+
+
+```
+
+The source's content URL is its repository identity; it is distinct from the display caption and REST API LUID. Host, site, repository identity, and field definitions must match the actual published source. Workbook format version `18.1` follows the supplied beta example and must be supported by the target environment.
+
+The app's worksheet also lists that source and its field dependencies under `worksheet/table/view`:
+
+```xml
+
+
+
+
+
+
+
+```
+
+`sqlproxy.sales` is the workbook-local connection key shared by the source definition, worksheet source, dependencies, and encoding reference. Each additional source needs its own consistent key and a connection on the app's worksheet. An empty `datasources` element leaves the app without a source to query.
+
+## Front-end resources and runtime data
+
+`content/index.html` loads bundled resources using paths relative to itself:
+
+```html
+
+
+
+
+
+ Regional Sales
+
+
+
+
+
+
+
Regional Sales
+
Connecting to Tableau…
+
+
+
+```
+
+`content/src/app.js` initializes Tableau, selects the connected source by name, and requests Region values at runtime:
+
+```javascript
+async function render() {
+ const output = document.getElementById('result');
+ try {
+ await tableau.extensions.initializeAsync();
+ const sources = await tableau.extensions.workbook.getAllDataSourcesAsync();
+ const source = sources.find((item) => item.name === 'Sales');
+ if (!source) throw new Error('The Sales data source is not connected.');
+
+ const result = await source.queryAsync({
+ fields: [{ fieldCaption: 'Region' }],
+ });
+ output.textContent = JSON.stringify(result, null, 2);
+ } catch (error) {
+ output.textContent = 'Unable to load regions. Check the data connection and access.';
+ console.error(error);
+ }
+}
+
+render();
+```
+
+The example displays the query response for inspection. A finished interface renders the returned rows, handles empty results, and updates queries as controls change. A minimal `styles.css` can contain `body { font-family: system-ui, sans-serif; margin: 1.5rem; }`.
+
+| Runtime API | Role |
+| --- | --- |
+| `initializeAsync()` | Establishes the extension's Tableau context before other API calls. |
+| `workbook.getAllDataSourcesAsync()` | Finds sources connected to the workbook in supported data app environments. |
+| Data source `queryAsync()` | Queries Tableau data using the requested fields, aggregations, and filters. |
+| Data source `readMetadata()` | Exposes data-source metadata. |
+| Extensions API `fetch()` | Makes supported Tableau REST API requests within the site's allowed methods and paths and the viewer's permissions. |
+
+Dashboard placement provides `dashboardContent`; worksheet placement provides `worksheetContent`. The workbook namespace in supported environments supplies workbook-level data access. Opening the HTML outside Tableau does not establish this runtime connection. See the [Extensions API reference](pathname:///api/) for supported method signatures.
+
+## Hosting and access
+
+Tableau hosts the packaged front end; external services remain separate dependencies. The app executes as the viewer, so access to the workbook and access to each published data source are both required. Manifest permissions do not override Tableau permissions or row-level security.
+
+Site controls govern packages, external origins, and Tableau REST API methods and paths. An app's access requirements should identify every external origin and REST operation it needs for administrator review. Passwords, tokens, and fixed copies of sensitive data do not belong in browser resources.
+
+A complete app loads entirely from its published package, reaches its connected sources, and handles loading, empty, error, and restricted-access states. Publishing and subsequent updates require the appropriate destination permissions. Details of site controls and access review are in [Manage Data Apps](./trex_dataapp_manage.md) and [Data App security](./trex_dataapp_security.md). The [Get Started guide](./trex_dataapp_getstarted.md) covers creating the same components with an AI coding assistant.
diff --git a/website/docs/dataapps/trex_dataapp_examples.md b/website/docs/dataapps/trex_dataapp_examples.md
new file mode 100644
index 00000000..fd72b204
--- /dev/null
+++ b/website/docs/dataapps/trex_dataapp_examples.md
@@ -0,0 +1,37 @@
+---
+title: Data App Samples
+description: Explore application ideas and extension samples to learn patterns for Tableau data apps.
+---
+
+The data apps beta is available only on Tableau Cloud.
+
+Start with a small application and inspect how it loads resources, initializes the Extensions API, and gets data. Then add the interactions needed for your users' workflow.
+
+## Example Data App scenarios
+
+The following are application ideas you can build on Tableau data:
+
+| Scenario | Application behavior | What to test |
+| --- | --- | --- |
+| Business performance report | Displays custom charts and metrics with controls for region and time period. | Queries return the intended aggregations and respect each viewer's data access. |
+| Customer exploration | Lets users narrow a list of customers and inspect trends for a selected customer. | Selection changes update the results and empty results have a clear explanation. |
+| Existing app migration | Replaces static data in a web app with runtime queries to Tableau data sources. | The published app uses Tableau data and loads its resources from the package. |
+
+These scenarios illustrate design patterns; they are not downloadable data app samples.
+
+## Learn from Dashboard and Viz Extension samples
+
+The existing Extensions API samples demonstrate useful patterns for data access, filtering, parameters, and event handling:
+
+- [Dashboard Extension Samples](../dashext/trex_examples.md) show applications that interact with dashboard content.
+- [Viz Extension Samples](../vizext/trex_viz_examples.md) show custom worksheet visualizations and interactions.
+
+Those samples use their own hosting and installation instructions. To adapt one as a data app, package its web resources with the workbook and use the deployment workflow supported by your beta environment. Review its API usage and dependencies rather than assuming every sample works unchanged.
+
+## Build a minimal example
+
+See [Data App Details](./trex_dataapp_details.md) for an entry page, a runtime data query, and the manifests and workbook connections that support them.
+
+## Review before publishing
+
+Check the application's resource paths, data permissions, declared external origins, and Tableau API access. Test the published workbook as an intended viewer, including loading, empty, and error states.
diff --git a/website/docs/dataapps/trex_dataapp_getstarted.md b/website/docs/dataapps/trex_dataapp_getstarted.md
new file mode 100644
index 00000000..a5a920b1
--- /dev/null
+++ b/website/docs/dataapps/trex_dataapp_getstarted.md
@@ -0,0 +1,102 @@
+---
+title: Get Started with Data Apps
+description: Vibe code a Tableau data app with Tableau MCP and the Tableau plugin, from your first prompt to a published app.
+tags: [Getting started]
+---
+
+_The data apps beta is available only on Tableau Cloud._
+
+Create a data app by describing what you want to an AI coding assistant. You provide details like the audience, questions, data source, interactions, and visual style. The assistant uses Tableau MCP and the Tableau plugin to connect your data, write the application, and package and publish it to Tableau Cloud. You review the app in Tableau and refine it through conversation.
+
+A data app combines a custom web interface with Tableau data access and hosting. For more about how it works, see [What are Tableau data apps?](./trex_dataapp_overview.md).
+
+## Before you begin
+
+You need:
+
+- Access to a Tableau Cloud site that supports the data apps beta.
+- A **Creator** or **Explorer (can publish)** site role and permission to publish to your intended destination.
+- A published Tableau data source that you can access. Have its name or link ready.
+- An AI client that supports MCP connections, the Tableau plugin, and code execution. The assistant needs to work with local files and run the plugin's scripts.
+
+:::note
+
+Your data app will often make Tableau service API calls to read and modify data and metadata. Your site administrator needs to enable access to each endpoint called for the data app. You may need to prompt your AI coding assistant to list the methods and paths used by the data app and make a request to your administrator.
+
+:::
+
+The workflow uses the `scaffold-data-app`, `publish-workbook`, and `request-workbook-upload` MCP tools, along with tools for finding data sources and reading their metadata. Tool availability depends on your Tableau environment and permissions. Ask the assistant to check these capabilities before it starts building.
+
+## Connect to Tableau MCP
+
+Tableau MCP lets your assistant discover Tableau content, inspect data source metadata, and create and publish the app. Follow the [Tableau MCP getting started guide](https://tableau.github.io/tableau-mcp/docs/getting-started) for connection options.
+
+For Tableau Cloud, use the [hosted Tableau MCP service](https://tableau.github.io/tableau-mcp/docs/hosted-tableau-mcp):
+
+1. Open your AI client's MCP or connector settings and add a connection to `https://mcp.tableau.com`.
+2. Complete the Tableau sign-in flow and connect to the site where you want to build the app.
+3. Start a new conversation with the connection enabled.
+
+If you install the Tableau plugin first, use its Tableau connector to complete this connection. You do not need a duplicate connection to the same service.
+
+If your organization runs Tableau MCP locally or hosts its own service, follow the configuration instructions in the MCP getting started guide instead.
+
+Check the connection with a prompt such as:
+
+> Find the published data source named Sales on my Tableau site and show me its available fields. Check whether the tools required to scaffold, upload, and publish a data app are available.
+
+If several data sources match, select the one you intend to use before continuing.
+
+:::note
+
+You can also clone the Tableau MCP repo and host the MCP locally instead of using the hosted MCP. Follow the [Tableau MCP getting-started guide](https://tableau.github.io/tableau-mcp/docs/getting-started) for instructions.
+
+:::
+
+## Get the Tableau plugin
+
+The [Tableau plugin](https://github.com/tableau/tableau-plugin) supplies the skills and scripts that guide the assistant through building a data app. Its [data app authoring skill](https://github.com/tableau/tableau-plugin/tree/main/src/plugin/skills/tableau-data-app-authoring) covers scaffolding, connecting a published data source, writing the interface, packaging, and publishing. Install the plugin so the assistant has these resources available.
+
+Follow the repository's [installation instructions](https://github.com/tableau/tableau-plugin#install-locally-codex-and-chatgpt-desktop) for your client. For a local installation from source, first clone the repository:
+
+```bash
+git clone https://github.com/tableau/tableau-plugin.git
+cd tableau-plugin
+```
+
+Then use the installation path for your client:
+
+- **Codex or ChatGPT desktop:** Run `./reload-plugin.sh openai`. This builds and installs the plugin, replacing an existing local Tableau plugin installation. Restart the desktop app, open **Plugins**, and select **Authenticate** or **Connect** for Tableau. Start a new task so it loads the plugin and connection.
+- **Claude desktop:** Run `./reload-plugin.sh claude` to build `dist/claude-tableau.zip`. In Claude, open **Customize → Plugins → Add → Upload plugin** and select the ZIP. Open the installed Tableau plugin's **Connectors** tab and connect Tableau. Enable code execution and start a new chat.
+
+The source installation requires Git and Python 3. The build script prepares its build dependencies. See the repository instructions for updates and other installation options.
+
+## Describe the app you want
+
+Tell the assistant to use the Tableau data app authoring skill. Include the app's purpose, audience, published data source, key metrics, controls, visual style, and publishing destination. For example:
+
+> Use the Tableau plugin's data app authoring skill to build a data app called Regional Sales Explorer. Use the published Sales data source on my Tableau Cloud site. The audience is regional sales managers who need to compare sales and profit across regions. Include summary metrics, a ranked regional bar chart, and a region filter. Use a clean layout with blue accents and clear labels. Inspect the data source metadata before choosing fields, and query Tableau data at runtime. Publish it as a new workbook in the Sales Analytics project and give me the link.
+
+Replace the example names with your own. If you do not know which data source to use, ask the assistant to find candidates and help you choose one first.
+
+## Build and publish with the assistant
+
+The assistant follows this workflow:
+
+1. **Check access and tools.** Verify publishing access and the required MCP capabilities.
+2. **Create the workspace.** Use `scaffold-data-app` to get a starter and apply its setup plan with the plugin's scripts.
+3. **Connect the data source.** Inspect the published source's identity and fields, then connect it to the workbook. The starter alone has no data source connected.
+4. **Write the app.** Implement the interface, runtime queries, filters, and loading, empty, and error states from your description.
+5. **Package and publish.** Use the plugin's packaging script to create a `.twbx` and publish it through Tableau MCP to your destination.
+
+You do not need to write the application code or assemble the workbook package yourself. If a required tool is unavailable or publishing fails, have the assistant report the missing capability or returned error so you can resolve it before continuing.
+
+## Review and refine in Tableau
+
+Open the published app in Tableau Cloud. Review the layout with real data, try each filter and interaction, and confirm that labels and metrics answer your original questions. Check loading, empty, and error states, and test access as an intended viewer. Visual review happens in Tableau after publishing.
+
+Request specific changes in the same conversation:
+
+> Sort regions by profit instead of sales, add a sales and profit toggle, and use a distinct color for negative profit. Keep the region filter. Update the app and republish it, replacing the workbook we just created.
+
+Before sharing, review the app's code and dependencies and confirm that intended viewers can access both the workbook and its published data source. See [data app security](./trex_dataapp_security.md) for the checks to make before sharing.
diff --git a/website/docs/dataapps/trex_dataapp_manage.md b/website/docs/dataapps/trex_dataapp_manage.md
new file mode 100644
index 00000000..4b74339d
--- /dev/null
+++ b/website/docs/dataapps/trex_dataapp_manage.md
@@ -0,0 +1,106 @@
+---
+title: Manage Data Apps
+description: Configure data apps for a Tableau Cloud site and manage individual packages in site Settings.
+---
+
+The data apps beta is available only on Tableau Cloud.
+
+As a site administrator, you manage data apps through the **Packages** tab on the site's **Settings** page. Data app enablement is configured **per site**. Review and configure these controls for each site where you want users to run data apps.
+
+Data apps include application resources in packages. The Packages tab lets you control the capabilities allowed for packages across the site and disable individual packages when needed.
+
+## Open the Packages tab
+
+1. Sign in to Tableau Cloud as a site administrator and select the site you want to manage.
+2. In the navigation pane, select **Settings**.
+3. On the site Settings page, select the **Packages** tab.
+
+Within this tab, use the **Settings / Packages** toggle to switch between two views:
+
+- **Settings** controls site-wide package enablement and allowed capabilities.
+- **Packages** lists all packages on the site and provides actions for individual packages.
+
+## Configure site-wide package settings
+
+Select **Settings** in the toggle to review the site's package configuration.
+
+
+
+### Enable packages on the site
+
+Use **Allow Packages on this Site** to control whether packages can run on the selected site. Enable this option when you want to allow data apps on the site.
+
+This is the site-wide control. To disable a specific package while allowing others to run, use the package's Actions menu in the [Packages view](#disable-an-individual-package).
+
+### Allow popups
+
+Use **Allow Packaged Extensions to trigger popups** to control whether extensions within packages can open popup windows. Review whether your data apps need this capability before allowing it.
+
+### Control external origins
+
+Under **Extension Package Allowed Origins**, specify the origins from which packages can load resources. Each origin must use HTTPS. Packages that declare a source outside this list will not run.
+
+Use **Add origin** to add an approved origin and the delete control beside an entry to remove it. Review the purpose of each external service and what data the app sends to it. See [data app security](./trex_dataapp_security.md#external-origins).
+
+### Control Tableau REST API access
+
+The `fetch()` method added to the Extensions API for this release enables data apps to make a curated set of Tableau REST API requests. Under **Tableau REST API Access**, control which of these requests elements of a package can make. Review the operations required by the data apps on your site before approving access.
+
+The **Allow all REST API access (all paths and methods)** option permits access across API paths and methods.
+
+When this option is unchecked, you must explicitly add the REST API requests available to extension code running in packages on the site. Requests outside the allowed list are blocked.
+
+1. Clear **Allow all REST API access (all paths and methods)**.
+2. Select **Add path** to add an entry for an allowed request.
+3. Specify the request's HTTP method and relative REST API URL path. Add an entry for each request your apps need.
+4. Select **Save** to apply the site's configuration.
+
+
+
+Use the `{api-version}` and `{site-id}` placeholders where appropriate in the path; the site ID is filled in automatically. Other resource ID placeholders must be supplied by the app. Approve only the operations required by your apps.
+
+These settings do not grant users additional Tableau content or data permissions. See [data app security](./trex_dataapp_security.md#tableau-rest-api-access) for guidance on reviewing API access.
+
+When you finish changing the site's settings, select **Save**.
+
+## View the packages on your site
+
+Select **Packages** in the toggle to display a table of all packages on the selected site.
+
+
+
+The table contains the following columns:
+
+| Column | Information |
+| --- | --- |
+| Name | The package name. |
+| Actions | A three-dot menu for actions on the individual package. |
+| Workbook | The workbook associated with the package. |
+| Package ID | The package identifier. |
+| Version | The package version. |
+| Author | The package author. |
+| Enabled | Whether the package is enabled. |
+| Default activation | The package's default activation setting. |
+| Extensions | The number of extensions listed for the package. |
+| Uploaded | When the package was uploaded. |
+
+Use the workbook and package metadata to identify the application you want to review. Check its enablement status before investigating why a data app is unavailable to users.
+
+## Disable an individual package
+
+To prevent a specific package from running on the site:
+
+1. In the **Packages** view, locate the package in the table.
+2. Select the three-dot menu in its **Actions** column.
+3. Select **Disable**.
+4. Check the package's **Enabled** status to verify the change.
+
+
+
+Coordinate with the workbook owner when disabling a package so they can address the impact on users. Review the package again when its code, external dependencies, or requested API access changes.
+
+## Related guidance
+
+- [Data app security](./trex_dataapp_security.md)
+- [Get Started with data apps](./trex_dataapp_getstarted.md)
+- [Data App Details](./trex_dataapp_details.md)
diff --git a/website/docs/dataapps/trex_dataapp_overview.md b/website/docs/dataapps/trex_dataapp_overview.md
new file mode 100644
index 00000000..d34f4506
--- /dev/null
+++ b/website/docs/dataapps/trex_dataapp_overview.md
@@ -0,0 +1,89 @@
+---
+title: What are Tableau Data Apps?
+description: Learn how Data Apps combine custom web applications with Tableau hosting and governed data.
+---
+
+The data Apps beta is available only on Tableau Cloud.
+
+A **data app** is a purpose-built interactive application built with code to help users explore data, make a decision, or complete a workflow. A data App gives your custom viz or dashboard extension runtime access to governed Tableau data sources through Extensions API and Tableau REST API methods.
+
+Data apps also host your extension's web resources on Tableau service. You build the interface using the Tableau Extensions API and bundle its HTML, JavaScript, CSS, and images inside a packaged workbook (`.twbx`). These resources are embedded in the workbook and published with it. Tableau hosts and serves them when users open the published content, so you do not need a separate web server for the app's front end.
+
+Your data app appears as a workbook in the Tableau Interface. A workbook can contain more than one data app.
+
+:::note Cloud-only Beta
+
+These pages describe data apps for the Cloud-only Beta. Before you begin, check with your administrator that your Tableau Cloud site is configured to allow your app. Supported capabilities depend on your site configuration.
+
+:::
+
+## Components of a Data App
+
+A data app includes:
+
+- An extension manifest (`.trex`) that describes a Dashboard or Viz Extension.
+- A web page and the JavaScript, CSS, images, and other resources it needs.
+- The Tableau Extensions API JavaScript library, which connects the application to Tableau.
+- A package that contains the extension and its resources, bundled with the workbook.
+
+A Tableau Package (`.tpkg`) is a container for application resources and metadata. The package supplies the resources; the data dpp combines them with Tableau data to provide the user experience.
+
+## What can you do with a Data App?
+
+Build an interface tailored to the questions and workflows your users need. For example, you can create a business report with custom charts, a guided exploration of customer activity, or a tool for comparing scenarios.
+
+A data app can query Tableau data at runtime rather than storing a fixed copy of the results in its source code. This lets you reuse your Tableau data layer, including extract refresh processes and row-level security. The results available to each viewer depend on their data access.
+
+You can also adapt an existing web application to use Tableau data and package it for Tableau hosting. Plan the data connections and permissions as part of that migration.
+
+## Extensions API methods for Data Apps
+
+Three methods added to the Extensions API for this release support data apps:
+
+| Method | Purpose |
+| --- | --- |
+| `queryAsync()` | Gets data from the configured data source asynchronously. |
+| `readMetadata()` | Gets a data source's metadata. |
+| `fetch()` | Makes a curated set of Tableau REST API requests, subject to the site's allowed API access and the viewing user's permissions. |
+
+For site controls and permission considerations, see [Manage Data Apps](./trex_dataapp_manage.md) and [Data App security](./trex_dataapp_security.md).
+
+## Who can create and view a Data App?
+
+To view a data app, you need:
+
+- View, full data query, and API access to the workbook containing the app
+- View, Connect and API access to each published data source the workbook connects to
+
+To create a data app, you need:
+
+- At least Creator or Explorer (can publish) role for the site containing the data app
+- Publish and Overwrite (to republish) access to the project for the data app
+- View, Connect and API access to each published data source the data app uses
+- Administrator site configuration allowing any Tableau REST API paths/methods the data app calls
+
+## How do Data Apps differ from Dashboard and Viz Extensions?
+
+A data app describes the complete application experience. Dashboard and Viz Extensions provide ways to integrate its interface with Tableau.
+
+| Concept | Purpose |
+| --- | --- |
+| Dashboard Extension | Adds a custom web application to a dashboard zone. |
+| Viz Extension | Adds a custom visualization to a worksheet through the Marks card. |
+| Data App | Combines a custom, code-authored interface with Tableau hosting and governed data for a decision or workflow. |
+
+Bundling the web resources with a workbook does not change where the interface appears: a packaged Dashboard Extension still appears on a dashboard, and a packaged Viz Extension still appears in a worksheet.
+
+## Hosting and governance
+
+Tableau-hosted front-end resources travel with the workbook, reducing the need to operate a separate web server for the app. This hosting covers the packaged web resources; it does not provide a runtime for your own server-side application code.
+
+Administrators control which external origins and Tableau REST APIs apps can access. Plan those dependencies explicitly and request only the access your app needs. Publishing an app does not grant its viewers additional permissions to Tableau data.
+
+## How is this different from the Tableau Embedding API?
+
+The [Tableau Embedding API](https://help.tableau.com/current/api/embedding_api/en-us/index.html) brings Tableau views into an application or website that you host. Data apps bundle custom application resources with Tableau content so Tableau can host them. Choose the approach that matches where you want users to work and how you want to deploy your application.
+
+## What's next?
+
+Follow [Get Started with Data Apps](./trex_dataapp_getstarted.md), or explore the components and code examples in [Data App Details](./trex_dataapp_details.md).
diff --git a/website/docs/dataapps/trex_dataapp_security.md b/website/docs/dataapps/trex_dataapp_security.md
new file mode 100644
index 00000000..421c2ca2
--- /dev/null
+++ b/website/docs/dataapps/trex_dataapp_security.md
@@ -0,0 +1,64 @@
+---
+title: Data App security
+description: Understand data app data permissions, hosted resources, external origins, and Tableau API access.
+---
+
+The data apps beta is available only on Tableau Cloud.
+
+Data apps execute custom code in the viewer's browser and query Tableau data at runtime. Review both the code and the access it requires before publishing. Tableau hosting and data permissions provide controls for the app, but app owners still need to review dependencies and how data is used.
+
+:::note Cloud-only Beta
+
+Confirm that the required settings are enabled on your Tableau Cloud site. Available controls and supported capabilities depend on your site configuration. Use the settings provided by your site when approving or disabling an app.
+
+:::
+
+## Content access and data permissions
+
+A data app runs as the viewing user and queries Tableau data at runtime. The `queryAsync()` and `readMetadata()` methods added for this release provide data and metadata access; they do not grant additional data-source permissions. Access to the workbook and access to its data are separate considerations: being able to open an app does not grant additional permissions to its data sources.
+
+Use Tableau content permissions to determine who can publish, view, and manage the workbook. Review the permissions and row-level security on the data sources that power the app. Test with accounts representing the intended audiences, rather than relying on the publisher's experience alone.
+
+Keep security rules in the data layer. Hiding a field or control in the app's interface does not prevent access to data that a query returns. Request only the data needed for the user's task, and avoid embedding a fixed copy of sensitive data in HTML or JavaScript.
+
+## Tableau-hosted resources
+
+The app's HTML, JavaScript, CSS, images, and other front-end resources are embedded in a packaged workbook and served by Tableau. This removes the need to operate a separate web server for those resources and lets you distribute the app with its workbook.
+
+Hosting does not replace code review. Review application code and third-party libraries before publishing, including code generated by an AI agent. The packaged resources run in the viewer's browser; do not place passwords, access tokens, or other secrets in them.
+
+Tableau hosting covers the bundled front-end resources. If the app depends on an external service, that service still requires its own availability, access controls, and approval.
+
+## External origins
+
+An external origin is a combination of protocol, host, and port, such as `https://api.example.com`. Apps declare the external origins needed to load resources or connect to services. Administrators control which origins are allowed.
+
+Before approving an origin, understand what the app uses it for. Loading a charting library from a CDN and sending query results to a third-party API have different implications for your data.
+
+| Dependency | Questions to review |
+| --- | --- |
+| Scripts and styles | Who maintains the library, and can the required version be bundled with the app? |
+| Images, fonts, and other assets | Does the app need to load them externally, or can they be included in the package? |
+| Third-party APIs | What information leaves Tableau, where is it sent, and does that use meet your organization's policies? |
+
+Approve only the origins required for the app's intended behavior. Bundling resources where practical reduces external dependencies. An allowed origin does not replace any authentication or browser access requirements imposed by the external service.
+
+## Tableau REST API access
+
+The `fetch()` method added to the Extensions API for this release enables data apps to make a curated set of Tableau REST API requests. Apps declare the Tableau REST API access they require for administrator review. Review these requests separately from external origins: an external dependency does not imply permission to call Tableau APIs.
+
+For each requested API, identify the action the app performs and why it is needed. Give particular attention to operations that create, change, or delete content. Approve only the access required for the workflow.
+
+Declared API access does not grant the viewer additional Tableau permissions. The app must use the supported Extensions API mechanism for Tableau REST requests and remain within the site's approved access.
+
+## Test security before sharing
+
+Test the published app with representative viewer accounts, including users with restricted data access. Confirm that the results respect data-source permissions and row-level security, and that requests stay within the approved external origins and Tableau API access.
+
+Verify that missing permissions and failed queries produce useful messages without exposing sensitive details. Repeat the review when the app changes its data sources, dependencies, or API usage.
+
+## Related guidance
+
+- [Manage data apps](./trex_dataapp_manage.md)
+- [Data App Details](./trex_dataapp_details.md)
+- [Get Started with data apps](./trex_dataapp_getstarted.md)
diff --git a/website/docs/debug/trex_debugging.md b/website/docs/debug/trex_debugging.md
index 73438ba6..60d343d1 100644
--- a/website/docs/debug/trex_debugging.md
+++ b/website/docs/debug/trex_debugging.md
@@ -185,7 +185,7 @@ While you are debugging your extension, there are times you might want to reload
Note that you don't need to close and reopen the Chromium browser every time you click **Reload**. You can start another debugging session by entering the URL (`http://localhost:8696`) in the Chromium address bar and selecting the extension from the page selector.
-For more information, see [What Happens When You Reload an Extension](./trex_reload.md).
+For more information, see [What Happens When You Reload an Extension?](./trex_reload.md).
diff --git a/website/docs/debug/trex_reload.md b/website/docs/debug/trex_reload.md
index ff5a471c..e50f3c21 100644
--- a/website/docs/debug/trex_reload.md
+++ b/website/docs/debug/trex_reload.md
@@ -1,12 +1,12 @@
---
-title: What Happens When you Reload an Extension
+title: What Happens When you Reload an Extension?
description: What happens when reloading an extension
---
When you create an dashboard extension or viz extension, you are often making frequent changes to the JavaScript code, the HTML pages, or the manifest file. It is helpful to see the results of those changes while you are working. Because dashboard and viz extensions are essentially web applications, you can do most of this quickly, without jumping through the hoops of building or compiling your code. However, because the extension is running inside a Tableau dashboard or worksheet, there are some differences you need to be aware of.
-## What happens at start up
+## What happens at start up?
When you first add an dashboard extension to a dashboard or viz extension to a worksheet, Tableau reads the extension's manifest file (`.trex`) and checks for errors. If the manifest file passes validation, Tableau registers the extension, loads the web page specified in the URL, and then caches information about the extension, such as the URL, the name of the extension, and the version number. Upon loading the web page, the extension runs the initialization code (`tableau.extensions.initializeAsync()`) that initializes the Extension API and then runs any JavaScript promises specified by the extension.
@@ -20,7 +20,7 @@ If you make changes to the manifest file after the extension is loaded and you w
Tableau loads the extension using the settings from the updated manifest file.
-## What happens when you reload the dashboard extension in Tableau
+## What happens when you reload the dashboard extension in Tableau?
You can reload a dashboard extension’s initial web page and state when you select **Reload** from the **More Options** menu in the upper-right corner of the dashboard container. This is equivalent to performing a hard-refresh in a browser. This is useful if you are making changes to the HTML pages or JavaScript code and you want to check your progress and see your changes in action. When you reload the extension this way, it does not pick up any changes you might have made to manifest file. For that, you need to remove the extension and add it back again.
diff --git a/website/docs/imgs/package-packages.png b/website/docs/imgs/package-packages.png
new file mode 100644
index 00000000..b03b6609
Binary files /dev/null and b/website/docs/imgs/package-packages.png differ
diff --git a/website/docs/imgs/package-settings.png b/website/docs/imgs/package-settings.png
new file mode 100644
index 00000000..97a522da
Binary files /dev/null and b/website/docs/imgs/package-settings.png differ
diff --git a/website/docs/imgs/packages-actions.png b/website/docs/imgs/packages-actions.png
new file mode 100644
index 00000000..274daacf
Binary files /dev/null and b/website/docs/imgs/packages-actions.png differ
diff --git a/website/docs/imgs/packages-paths.png b/website/docs/imgs/packages-paths.png
new file mode 100644
index 00000000..365ea41f
Binary files /dev/null and b/website/docs/imgs/packages-paths.png differ
diff --git a/website/docs/installation.md b/website/docs/installation.md
index 43d6ee86..676422bd 100644
--- a/website/docs/installation.md
+++ b/website/docs/installation.md
@@ -78,7 +78,7 @@ SSH
### Requirements for using extensions in Tableau
-To use Tableau dashboard and viz extensions in Tableau, you need one of the following versions of Tableau.
+To use Tableau dashboard extensions, viz extensions, or data apps in Tableau, you need one of the following versions of Tableau. The data apps beta is available only on Tableau Cloud.
For dashboard extensions:
@@ -92,6 +92,9 @@ For viz extensions:
* Tableau Server 2024.1 and later
* Tableau Cloud
+For data apps (Cloud-only Beta):
+
+* Tableau Cloud
### Security requirements
@@ -99,4 +102,4 @@ For viz extensions:
To run extensions on Tableau Server or Tableau Cloud, support for extensions must be enabled, and depending upon the extension and the data access it requires, the extension might need to be added to the safe list for the site. See
[Manage Dashboard Extensions on Tableau Server](https://onlinehelp.tableau.com/current/server/en-us/dashboard_extensions_server.htm) or [Manage Dashboard Extensions on Tableau Cloud](https://onlinehelp.tableau.com/current/online/en-us/dashboard_extensions_server.htm) for more information.
-
+Special care must be taken for data apps, available only on Tableau Cloud during the beta, to ensure that security concerns are addressed. See [Manage data apps](./dataapps/trex_dataapp_manage.md) and [data app security](./dataapps/trex_dataapp_security.md) for more information.
diff --git a/website/docs/security/trex_data_access.md b/website/docs/security/trex_data_access.md
index 85df5b03..70422174 100644
--- a/website/docs/security/trex_data_access.md
+++ b/website/docs/security/trex_data_access.md
@@ -14,7 +14,7 @@ Starting in Tableau 2020.2, Tableau introduced a data model that supports flexib
Because the data model changes the way the underlying data can be stored, some of the existing APIs will no longer work.
For more information about the data model in Tableau, see [The Tableau Data Model](https://help.tableau.com/current/pro/desktop/en-us/datasource_datamodel.htm).
-## What happens when extensions access full data
+## What happens when extensions access full data?
As a developer, you can choose the features and capabilities to implement using the Extensions API. One of these is the ability of the extension to access the underlying data in the dashboard or workbook. The `Worksheet` and `Datasource` interfaces have methods that return (as a promise) data tables containing the underlying data of the workbook or data source. The `Datasource` interface has additional methods, `getLogicalTablesAsync()`, `getActiveTablesAsync()` (Deprecated), and `getConnectionSummariesAsync()` that return the names of the active tables and fields in the data source, and the summary descriptions of the data source connections.
@@ -73,7 +73,7 @@ Error: internal-error: permission-denied: Missing required permission to run get
---
-## What happens when users add your extension
+## What happens when users add your extension?
When users add an extension that requires full-data access, Tableau displays a prompt that provides the name of the extension, the URL of the extension, and brief description about the access that the extension has to the data in the workbook. Users can click **Allow** to load the extension. If a user clicks **Cancel**, the extension is not loaded and the user returns to the **Choose an Extension** dialog box.
@@ -83,7 +83,7 @@ The name of the extension and its URL come from the values you add to the manife
---
-## What happens when users open a workbook that uses an extension
+## What happens when users open a workbook that uses an extension?
When users open a dashboard that has an extension that requires full-data access, Tableau displays a prompt that lists the names of the all the extensions in the dashboard. Users can click **Allow** to load the dashboard.
diff --git a/website/docs/trex_api_about.md b/website/docs/trex_api_about.md
index d829e8c1..438df16b 100644
--- a/website/docs/trex_api_about.md
+++ b/website/docs/trex_api_about.md
@@ -10,6 +10,19 @@ The Tableau Extensions API is organized by namespaces. The type of extension you
| ----- | ------- |
| Dashboard extensions | For example, if you create and register a dashboard extension, the extension will have access to the `dashboardContent` namespace, which provides access to the dashboard object. When you have the dashboard object, you have access to all elements in the dashboard, including the worksheets, marks, filters, parameters, and data sources. |
| Viz extensions | If you create and register a viz extension, the extension will have access to the `worksheetContent` namespace, which provides access to the worksheet object. When you have the worksheet object, you have access to all elements in the worksheet, including the marks, filters, parameters, and data sources.|
+| [Data apps (Cloud-only Beta)](./dataapps/trex_dataapp_overview.md) | Data apps are available only on Tableau Cloud during the beta. They combine a custom web interface with Tableau hosting and runtime access to Tableau data. The app's Dashboard or Viz Extension registration determines access to `dashboardContent` or `worksheetContent`. In supported environments, the `workbook` namespace provides access to workbook data sources, which the app can query using `queryAsync()`. See [Get Started with data apps](./dataapps/trex_dataapp_getstarted.md) for setup guidance. |
+
+## Methods added for Data Apps
+
+The data apps beta is available only on Tableau Cloud. Three methods added to the Extensions API for this release support data apps:
+
+| Method | Purpose |
+| --- | --- |
+| `queryAsync()` | Gets data from the configured data source asynchronously. |
+| `readMetadata()` | Gets a data source's metadata. |
+| `fetch()` | Makes a curated set of Tableau REST API requests, subject to the site's allowed API access and the viewing user's permissions. |
+
+See [Manage data apps](./dataapps/trex_dataapp_manage.md) and [data app security](./dataapps/trex_dataapp_security.md) for the controls that apply to these requests.
## Navigating the top-level `tableau` and `extensions` namespaces
@@ -21,7 +34,7 @@ A viz extension is another type of extension. When a extension is registered as
The type of extension you have registered determines what namespaces will be available. Some namespaces, like the `settings`, `environment`, and `ui` are available to all extensions.
-The `extensions` namespace has one method `initializeAsync()` that is used to initialize the extension. When this method is called, it also triggers Tableau to configure the Extensions API. Like the Tableau JavaScript API, the Extensions API follows the [CommonJS Promises/A standard](http://wiki.commonjs.org/wiki/Promises/A) for asynchronous method calls.
+Call `tableau.extensions.initializeAsync()` to initialize the extension before using the Extensions API. When this method is called, it also triggers Tableau to configure the Extensions API. Like the Tableau JavaScript API, the Extensions API follows the [CommonJS Promises/A standard](http://wiki.commonjs.org/wiki/Promises/A) for asynchronous method calls.
@@ -170,4 +183,3 @@ classDiagram
-
diff --git a/website/docs/vizext/trex_viz_overview.md b/website/docs/vizext/trex_viz_overview.md
index 001fbb20..8c082f4c 100644
--- a/website/docs/vizext/trex_viz_overview.md
+++ b/website/docs/vizext/trex_viz_overview.md
@@ -1,5 +1,5 @@
---
-title: What is a Tableau Viz Extension
+title: What is a Tableau Viz Extension?
description: Describes a viz extension
---
diff --git a/website/sidebars.js b/website/sidebars.js
index 60755481..8136a639 100644
--- a/website/sidebars.js
+++ b/website/sidebars.js
@@ -7,6 +7,31 @@ const sidebars = {
'installation',
'trex_api_about',
'trex_tableau_help',
+ {
+ type: 'category',
+ label: 'Dashboard Extensions',
+ link: { type: 'doc', id: 'dashext/index' },
+ items: [
+ 'dashext/trex_getstarted',
+ 'dashext/trex_create',
+ 'dashext/trex_overview',
+ 'dashext/trex_manifest',
+ 'dashext/trex_examples',
+ ],
+ },
+ {
+ type: 'category',
+ label: '(Cloud-only Beta) Data Apps',
+ link: { type: 'doc', id: 'dataapps/index' },
+ items: [
+ 'dataapps/trex_dataapp_getstarted',
+ 'dataapps/trex_dataapp_overview',
+ 'dataapps/trex_dataapp_details',
+ 'dataapps/trex_dataapp_manage',
+ 'dataapps/trex_dataapp_security',
+ 'dataapps/trex_dataapp_examples',
+ ],
+ },
{
type: 'category',
label: 'Viz Extensions',
@@ -18,19 +43,7 @@ const sidebars = {
'vizext/trex_viz_manifest',
'vizext/trex_viz_examples',
],
- },
- {
- type: 'category',
- label: 'Dashboard Extensions',
- link: { type: 'doc', id: 'dashext/index' },
- items: [
- 'dashext/trex_getstarted',
- 'dashext/trex_create',
- 'dashext/trex_overview',
- 'dashext/trex_manifest',
- 'dashext/trex_examples',
- ],
- },
+ },
/* {
type: 'category',
label: 'Basic Concepts',
@@ -109,7 +122,7 @@ const sidebars = {
'trex_release-notes',
'trex_known_issues',
],
- },
+ },
],