# Embedding custom Amazon Quick Sight assets into your application
You can use Amazon Quick Sight embedded analytics to embed custom Amazon Quick Sight assets into your application that are tailored to meet your business needs. For embedded dashboards and visuals, Amazon Quick Sight authors can add filters and drill downs that readers can access as they navigate the dashboard or visual. Amazon Quick Sight developers can also use the Amazon Quick Sight SDKs to build tighter integrations between their SaaS applications and their Amazon Quick Sight embedded assets to add datapoint callback actions to visuals on a dashboard at runtime.
For more information about the Amazon Quick Sight SDKs, see the `amazon-quicksight-embedding-sdk` on [GitHub](https://github.com/awslabs/amazon-quicksight-embedding-sdk) or [NPM](https://www.npmjs.com/package/amazon-quicksight-embedding-sdk).
Following, you can find descriptions of how to use the Amazon Quick Sight SDKs to customize your Amazon Quick Sight embedded analytics.
**Topics**
+ [
# Adding embedded callback actions at runtime in Amazon Quick Sight
](embedding-custom-actions-callback.md)
+ [
# Filtering data at runtime for Amazon Quick Sight embedded dashboards and visuals
](embedding-runtime-filtering.md)
+ [
# Customize the look and feel of Amazon Quick Sight embedded dashboards and visuals
](embedding-runtime-theming.md)
+ [
# Using the Amazon Quick Sight Embedding SDK to enable shareable links to embedded dashboard views
](embedded-view-sharing.md)
# Adding embedded callback actions at runtime in Amazon Quick Sight
Use embedded datapoint callback actions to build tighter integrations between your software as a service (SaaS) application and your Amazon Quick Sight embedded dashboards and visuals. Developers can register datapoints to be called back with the Amazon Quick Sight embedding SDK. When you register a callback action for a visual, readers can select a datapoint on the visual to receive a callback that provides data specific to the selected data point. This information can be used to flag key records, compile raw data specific to the datapoint, capture records, and compile data for backend processes.
Embedded callbacks aren't supported for custom visual content, text boxes, or insights.
Before you begin registering datapoints for callback, update the Embedding SDK to version 2.3.0. For more information about using the Amazon Quick Sight Embedding SDK, see the [amazon-quicksight-embedding-sdk](https://github.com/awslabs/amazon-quicksight-embedding-sdk) on GitHub.
A datapoint callback can be registered to one or more visuals at runtime through the Amazon Quick Sight SDK. You can also register a datapoint callback to any interaction supported by the [VisualCustomAction](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_VisualCustomAction.html) API structure. This allows the datapoint callback to initiate when the user selects the datapoint on the visual or when the datapoint is selected from the datapoint context menu. The following example registers a datapoint callback that the reader initiates when they select a datapoint on the visual.
```
/const MY_GET_EMBED_URL_ENDPOINT =
"https://my.api.endpoint.domain/MyGetEmbedUrlApi"; // Sample URL
// The dashboard id to embed
const MY_DASHBOARD_ID = "my-dashboard"; // Sample ID
// The container element in your page that will have the embedded dashboard
const MY_DASHBOARD_CONTAINER = "#experience-container"; // Sample ID
// SOME HELPERS
const ActionTrigger = {
DATA_POINT_CLICK: "DATA_POINT_CLICK",
DATA_POINT_MENU: "DATA_POINT_MENU",
};
const ActionStatus = {
ENABLED: "ENABLED",
DISABLED: "DISABLED",
};
// This function makes a request to your endpoint to obtain an embed url for a given dashboard id
// The example implementation below assumes the endpoint takes dashboardId as request data
// and returns an object with EmbedUrl property
const myGetEmbedUrl = async (dashboardId) => {
const apiOptions = {
dashboardId,
};
const apiUrl = new URL(MY_GET_EMBED_URL_ENDPOINT);
apiUrl.search = new URLSearchParams(apiOptions).toString();
const apiResponse = await fetch(apiUrl.toString());
const apiResponseData = await apiResponse.json();
return apiResponseData.EmbedUrl;
};
// This function constructs a custom action object
const myConstructCustomActionModel = (
customActionId,
actionName,
actionTrigger,
actionStatus
) => {
return {
Name: actionName,
CustomActionId: customActionId,
Status: actionStatus,
Trigger: actionTrigger,
ActionOperations: [
{
CallbackOperation: {
EmbeddingMessage: {},
},
},
],
};
};
// This function adds a custom action on the first visual of first sheet of the embedded dashboard
const myAddVisualActionOnFirstVisualOfFirstSheet = async (
embeddedDashboard
) => {
// 1. List the sheets on the dashboard
const { SheetId } = (await embeddedDashboard.getSheets())[0];
// If you'd like to add action on the current sheet instead, you can use getSelectedSheetId method
// const SheetId = await embeddedDashboard.getSelectedSheetId();
// 2. List the visuals on the specified sheet
const { VisualId } = (await embeddedDashboard.getSheetVisuals(SheetId))[0];
// 3. Add the custom action to the visual
try {
const customActionId = "custom_action_id"; // Sample ID
const actionName = "Flag record"; // Sample name
const actionTrigger = ActionTrigger.DATA_POINT_CLICK; // or ActionTrigger.DATA_POINT_MENU
const actionStatus = ActionStatus.ENABLED;
const myCustomAction = myConstructCustomActionModel(
customActionId,
actionName,
actionTrigger,
actionStatus
);
const response = await embeddedDashboard.addVisualActions(
SheetId,
VisualId,
[myCustomAction]
);
if (!response.success) {
console.log("Adding visual action failed", response.errorCode);
}
} catch (error) {
console.log("Adding visual action failed", error);
}
};
const parseDatapoint = (visualId, datapoint) => {
datapoint.Columns.forEach((Column, index) => {
// FIELD | METRIC
const columnType = Object.keys(Column)[0];
// STRING | DATE | INTEGER | DECIMAL
const valueType = Object.keys(Column[columnType])[0];
const { Column: columnMetadata } = Column[columnType][valueType];
const value = datapoint.RawValues[index][valueType];
const formattedValue = datapoint.FormattedValues[index];
console.log(
`Column: ${columnMetadata.ColumnName} has a raw value of ${value}
and formatted value of ${formattedValue.Value} for visual: ${visualId}`
);
});
};
// This function is used to start a custom workflow after the end user selects a datapoint
const myCustomDatapointCallbackWorkflow = (callbackData) => {
const { VisualId, Datapoints } = callbackData;
parseDatapoint(VisualId, Datapoints);
};
// EMBEDDING THE DASHBOARD
const main = async () => {
// 1. Get embed url
let url;
try {
url = await myGetEmbedUrl(MY_DASHBOARD_ID);
} catch (error) {
console.log("Obtaining an embed url failed");
}
if (!url) {
return;
}
// 2. Create embedding context
const embeddingContext = await createEmbeddingContext();
// 3. Embed the dashboard
const embeddedDashboard = await embeddingContext.embedDashboard(
{
url,
container: MY_DASHBOARD_CONTAINER,
width: "1200px",
height: "300px",
resizeHeightOnSizeChangedEvent: true,
},
{
onMessage: async (messageEvent) => {
const { eventName, message } = messageEvent;
switch (eventName) {
case "CONTENT_LOADED": {
await myAddVisualActionOnFirstVisualOfFirstSheet(embeddedDashboard);
break;
}
case "CALLBACK_OPERATION_INVOKED": {
myCustomDatapointCallbackWorkflow(message);
break;
}
}
},
}
);
};
main().catch(console.error);
```
You can also configure the preceding example to initiate datapoint callback when the user opens the context menu. To do this with the preceding example, set the value of `actionTrigger` to `ActionTrigger.DATA_POINT_MENU`.
After a datapoint callback is registered, it's applied to most datapoints on the specified visual or visuals. Callbacks don't apply to totals or subtotals on visuals. When a reader interacts with a datapoint, a `CALLBACK_OPERATION_INVOKED` message is emitted to the Amazon Quick Sight embedding SDK. This message is captured by the `onMessage` handler. The message contains the raw and display values for the full row of data associated with the datapoint that is selected. It also contains the column metadata for all columns in the visual that the datapoint is contained in. The following is an example of a `CALLBACK_OPERATION_INVOKED` message.
```
{
CustomActionId: "custom_action_id",
DashboardId: "dashboard_id",
SheetId: "sheet_id",
VisualId: "visual_id",
DataPoints: [
{
RawValues: [
{
String: "Texas" // 1st raw value in row
},
{
Integer: 1000 // 2nd raw value in row
}
],
FormattedValues: [
{Value: "Texas"}, // 1st formatted value in row
{Value: "1,000"} // 2nd formatted value in row
],
Columns: [
{ // 1st column metadata
Dimension: {
String: {
Column: {
ColumnName: "State",
DatsetIdentifier: "..."
}
}
}
},
{ // 2nd column metadata
Measure: {
Integer: {
Column: {
ColumnName: "Cancelled",
DatsetIdentifier: "..."
},
AggregationFunction: {
SimpleNumericalAggregation: "SUM"
}
}
}
}
]
}
]
}
```
# Filtering data at runtime for Amazon Quick Sight embedded dashboards and visuals
You can use filter methods in the Amazon Quick Sight embedding SDK to leverage the power of Amazon Quick Sight filters within your software as a service (SaaS) application at runtime. Runtime filters allow business owners to integrate their application with their embedded Amazon Quick Sight dashboards and visuals. To accomplish this, create customized filter controls in your application and apply filter presets based on data from your application. Then, developers can personalize filter configurations for end users at runtime.
Developers can create, query, update, and remove Amazon Quick Sight filters on an embedded dashboard or visual from their application with the Amazon Quick Sight Embedding SDK. Create Amazon Quick Sight filter objects in your application with the [FilterGroup](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_FilterGroup.html) data model and apply them to embedded dashboards and visuals using the filter methods. For more information about using the Amazon Quick Sight Embedding SDK, see the [amazon-quicksight-embedding-sdk](https://github.com/awslabs/amazon-quicksight-embedding-sdk) on GitHub.
**Prerequisites**
Before you can get started, make sure that you are using the Amazon Quick Sight Embedding SDK version 2.5.0 or higher.
## Terminology and concepts
The following terminology can be useful when working with embedded runtime filtering.
+ *Filter group* – A group of individual filters. Filters that are located within a `FilterGroup` are OR-ed with each other. Filters within a [FilterGroup](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_FilterGroup.html) are applied to the same sheets or visuals.
+ *Filter* – A single filter. The filter can be a category, numeric, or datetime filter type. For more information on filters, see [Filter](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_Filter.html).
## Setting up
Before you begin, make sure that you have the following assets and information prepared.
+ The sheet ID of the sheet that you want to scope the `FilterGroup` to. This can be obtained with the `getSheets` method in the Embedding SDK.
+ The dataset and column identifier of the dataset that you want to filter. This can be obtained through the [DescribeDashboardDefinition](https://docs.aws.amazon.com/APIReference/API_DescribeDashboardDefinition.html) API operation.
Depending on the column type that you use, there might be restrictions on the types of filters that can be added to an embedded asset. For more information on filter restrictions, see [Filter](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_Filter.html).
+ The visual ID of the visual that you want to scope the `FilterGroup` to, if applicable. This can be obtained by using the `getSheetVisuals` method in the Embedding SDK.
In addition to the `getSheetVisuals` method, the `FilterGroup` that you add can only be scoped to the currently selected sheet.
To use this feature, you must already have a dashboard or visual embedded into your application through the Amazon Quick Sight Embedding SDK. For more information about using the Amazon Quick Sight Embedding SDK, see the [amazon-quicksight-embedding-sdk](https://github.com/awslabs/amazon-quicksight-embedding-sdk) on GitHub.
## SDK method interface
**Dashboard embedding getter methods**
The following table describes different dashboard embedding getter methods that developers can use.
| Method | Description |
| --- | --- |
| `getFilterGroupsForSheet(sheetId: string) ` | Returns all FilterGroups that are currently scoped to the sheet that is supplied in the parameter. |
| `getFilterGroupsForVisual(sheetId: string, visualId: string)` | Returns all `FilterGroups` that are scoped to the visual that is supplied in the parameter. |
If the sheet that is supplied in the parameter is not the currently selected sheet of the embedded dashboard, the above methods return an error.
**Visual embedding getter methods**
The following table describes different visual embedding getter methods that developers can use.
| Method | Description |
| --- | --- |
| `getFilterGroups()` | Returns all `FilterGroups` that are currently scoped to the embedded visual. |
**Setter methods**
The following table describes different setter methods that developers can use for dashboard or visual embedding.
| Method | Description |
| --- | --- |
| `addFilterGroups(filterGroups: FilterGroup[])` | Adds and applies the supplied **FilterGroups** to the embedded dashboard or visual. A `ResponseMessage` that indicates whether the addition was successful is returned. |
| `updateFilterGroups(filterGroups: FilterGroup[])` | Updates the `FilterGroups` on the embedded experience that contains the same `FilterGroupId` as the `FilterGroup` that is supplied in the parameter. A `ResponseMessage` that indicates whether the update was successful is returned. |
| `removeFilterGroups(filterGroupsOrIds: FilterGroup[] \| string[])` | Removes the supplied FilterGroups from the dashboard and returns a `ResponseMessage` that indicates whether the removal attempt is successful. |
The `FilterGroup` that is supplied must be scoped to the embedded sheet or visual that is currently selected.
# Customize the look and feel of Amazon Quick Sight embedded dashboards and visuals
You can use the Amazon Quick Sight Embedding SDK (version 2.5.0 and higher) to make changes to the theming of your embedded Amazon Quick Sight dashboards and visuals at runtime. Runtime theming makes it easier to integrate your Software as a service (SaaS) application with your Amazon Quick Sight embedded assets. Runtime theming allows you to synchronize the theme of your embedded content with the themes of the parent application that your Amazon Quick Sight assets are embedded into. You can also use runtime theming to add customization options for readers. Theming changes can be applied to embedded assets at initialization or throughout the lifetime of your embedded dashboard or visual.
For more information about themes, see [Using themes in Amazon Quick Sight](themes-in-quicksight.md). For more information about using the Amazon Quick Sight Embedding SDK, see the [amazon-quicksight-embedding-sdk](https://github.com/awslabs/amazon-quicksight-embedding-sdk) on GitHub.
**Prerequisites**
Before you can get started, make sure that you have the following prerequisites.
+ You are using the Amazon Quick Sight Embedding SDK version 2.5.0 or higher.
+ Permissions to access the theme that you want to work with. To grant permissions to a theme in Amazon Quick Sight, make a `UpdateThemePermissions` API call or use the **Share** icon next to the theme in the Amazon Quick Sight console's analysis editor.
## Terminology and concepts
The following terminology can be useful when working with embedded runtime theming.
+ *Theme* – A collection of settings that you can apply to multiple analyses and dashboards that change how the content is displayed.
+ *ThemeConfiguration* – A configuration object that contains all of the display properties for a theme.
+ *Theme Override* – A `ThemeConfiguration` object that is applied to the active theme to override some or all aspects of how content is displayed.
+ *Theme ARN * – An Amazon Resource Name (ARN) that identifies a Amazon Quick Sight theme. Following is an example of custom theme ARN.
`arn:aws:quicksight:region:account-id:theme/theme-id`
Amazon Quick Sight provided starter themes don't have a region in their theme ARN. Following is an example of a starter theme ARN.
`arn:aws:quicksight::aws:theme/CLASSIC`
## Setting up
Make sure that you have the following information ready to get started working with runtime theming.
+ The theme ARNs of the themes that you want to use. You can choose an existing theme, or you can create a new one. To obtain a list all themes and theme ARNs in your Amazon Quick Sight account, make a call to the [ListThemes](https://docs.aws.amazon.com/quicksight/latest/APIReference/API_ListThemes.html) API operation. For information on preset Amazon Quick Sight themes, see [Setting a default theme for Amazon Quick analyses with the Amazon Quick APIs](customizing-quicksight-default-theme.md).
+ If you are using registered user embedding, make sure that the user has access to the themes that you want to use.
If you are using anonymous user embedding, pass a list of theme ARNs to the `AuthorizedResourceArns` parameter of the `GenerateEmbedUrlForAnonymousUser` API. Anonymous users are granted access to any theme that is listed in the `AuthorizedResourceArns` parameter.
## SDK method interface
**Setter methods**
The following table describes different setter methods that developers can use for runtime theming.
| Method | Description |
| --- | --- |
| `setTheme(themeArn: string)` | Replaces the active theme of a dashboard or visual with another theme. If applied, the theme override is removed. An error is returned if you don't have access to the theme or if the theme doesn't exist. |
| `setThemeOverride(themeOverride: ThemeConfiguration)` | Sets a dynamic `ThemeConfiguration` to override the current active theme. This replaces the previously set theme override. Any values that are not supplied in the new `ThemeConfiguration` are defaulted to the values in the currently active theme. An error is returned if the `ThemeConfiguration` that you supply is invalid. |
## Initializing embedded content with a theme
To initialize an embedded dashboard or visual with a non-default theme, define a `themeOptions` object on the `DashboardContentOptions` or `VisualContentOptions` parameters, and set the `themeArn` property within `themeOptions` to the desired theme ARN.
The following example initializes an embedded dashboard with the `MIDNIGHT` theme.
```
import { createEmbeddingContext } from 'amazon-quicksight-embedding-sdk';
const embeddingContext = await createEmbeddingContext();
const {
embedDashboard,
} = embeddingContext;
const frameOptions = {
url: '',
container: '#experience-container',
};
const contentOptions = {
themeOptions: {
themeArn: "arn:aws:quicksight::aws:theme/MIDNIGHT"
}
};
// Embedding a dashboard experience
const embeddedDashboardExperience = await embedDashboard(frameOptions, contentOptions);
```
## Initializing embedded content with a theme override
Developers can use theme overrides to define the theme of an embedded dashboard or visual at runtime. This allows the dashboard or visual to inherit a theme from a third-party application without the need to pre-configure a theme within Amazon Quick Sight. To initialize an embedded dashboard or visual with a theme override, set the `themeOverride` property within `themeOptions` in either the `DashboardContentOptions` or `VisualContentOptions` parameters. The following example overrides the font of a dashboard's theme from the default font to `Amazon Ember`.
```
import { createEmbeddingContext } from 'amazon-quicksight-embedding-sdk';
const embeddingContext = await createEmbeddingContext();
const {
embedDashboard,
} = embeddingContext;
const frameOptions = {
url: '',
container: '#experience-container',
};
const contentOptions = {
themeOptions: {
"themeOverride":{"Typography":{"FontFamilies":[{"FontFamily":"Comic Neue"}]}}
}
};
// Embedding a dashboard experience
const embeddedDashboardExperience = await embedDashboard(frameOptions, contentOptions);
```
## Initializing embedded content with preloaded themes
Developers can configure a set of dashboard themes to be preloaded on initialization. This is most beneficial for quick toggling between different views, for example dark and light modes. An embedded dashboard or visual can be initialized with up to 5 preloaded themes. To use preloaded themes, set the `preloadThemes` property in either `DashboardContentOptions` or `VisualContentOptions` with an array of up to 5 `themeArns`. The following example preloads the `Midnight` and `Rainier` starter themes to a dashboard.
```
import { createEmbeddingContext } from 'amazon-quicksight-embedding-sdk';
const embeddingContext = await createEmbeddingContext();
const {
embedDashboard,
} = embeddingContext;
const frameOptions = {
url: '',
container: '#experience-container',
};
const contentOptions = {
themeOptions: {
"preloadThemes": ["arn:aws:quicksight::aws:theme/RAINIER", "arn:aws:quicksight::aws:theme/MIDNIGHT"]
}
};
// Embedding a dashboard experience
const embeddedDashboardExperience = await embedDashboard(frameOptions, contentOptions);
```
# Using the Amazon Quick Sight Embedding SDK to enable shareable links to embedded dashboard views
Amazon Quick Sight developers can use the Amazon Quick Sight Embedding SDK (version 2.8.0 and higher) to allow readers of embedded dashboards to receive and distribute shareable links to their view of an embedded dashboard. Developers can use dashboard or console embedding to generate a shareable link to their application page with Amazon Quick Sight's reference encapsulated using the Amazon Quick Sight Embedding SDK. Amazon Quick Sight Readers can then send this shareable link to their peers. When their peer accesses the shared link, they are taken to the page on the application that contains the embedded Amazon Quick Sight dashboard. Developers can also generate and save shareable links of dashboard views that can be used as a bookmarks for anonymous readers of Amazon Quick Sight when using anonymous embedding.
**Prerequisites**
Before you get started, make sure that you are using the Amazon Quick Sight Embedding SDK version 2.8.0 or higher
**Topics**
+ [
# Enabling the `SharedView` feature configuration for Amazon Quick Sight embedded analytics
](embedded-view-sharing-set-up.md)
+ [
# Creating a shared view with the Amazon Quick Sight `createSharedView` API
](embedded-view-sharing-sdk-create.md)
+ [
# Consuming a shared Amazon Quick Sight view
](embedded-view-sharing-sdk-consume.md)
# Enabling the `SharedView` feature configuration for Amazon Quick Sight embedded analytics
When you create an the embedded instance with the Amazon Quick Sight API, set the value of `SharedView` in the `FeatureConfigurations` payload to `true`, as shown in the example below. `SharedView` overrides the `StatePersistence` configurations for registered users who access embedded dashboards. If a dashboard user has `StatePersistence` disabled and `SharedView` enabled, their state will persist.
```
const generateNewEmbedUrl = async () => {
const generateUrlPayload = {
experienceConfiguration: {
QuickSightConsole: {
FeatureConfigurations: {
"SharedView": {
"Enabled": true
},
},
},
}
const result: GenerateEmbedUrlResult = await generateEmbedUrlForRegisteredUser(generateUrlPayload);
return result.url;
};
```
# Creating a shared view with the Amazon Quick Sight `createSharedView` API
After you update the Embedding SDK to version 2.8.0 or higher, use the `createSharedView` API to create a new shared view. Record the `sharedViewId` and the `dashboardId` that the operation returns. The example below creates a new shared view.
```
const response = await embeddingFrame.createSharedView();
const sharedViewId = response.message.sharedViewId;
const dashboardId = response.message.dashboardId;
```
`createSharedView` can only be called when a user views a dashboard. For console-specific shared view creation, make sure that users are on the dashboard page before you enable the `createSharedView` action. You can do this with the `PAGE_NAVIGATION` event, shown in the example below.
```
const contentOptions = {
onMessage: async (messageEvent, metadata) => {
switch (messageEvent.eventName) {
case 'CONTENT_LOADED': {
console.log("Do something when the embedded experience is fully loaded.");
break;
}
case 'ERROR_OCCURRED': {
console.log("Do something when the embedded experience fails loading.");
break;
}
case 'PAGE_NAVIGATION': {
setPageType(messageEvent.message.pageType);
if (messageEvent.message.pageType === 'DASHBOARD') {
setShareEnabled(true);
} else {
setShareEnabled(false);
}
break;
}
}
}
};
```
# Consuming a shared Amazon Quick Sight view
After you create a new shared view, use the Embedding SDK to make the shared view consumable for other users. The examples below set up a consumable shared view for an embedded dashboard in Amazon Quick Sight.
------
#### [ With an appended URL ]
Append the `sharedViewId` to the embed URL, under ` /views/{viewId}`, and expose this URL to your users. Users can use this URL to will navigate to that shared view.
```
const response = await dashboardFrame.createSharedView();
const newEmbedUrl = await generateNewEmbedUrl();
const formattedUrl = new URL(newEmbedUrl);
formattedUrl.pathname = formattedUrl.pathname.concat('/views/' + response.message.sharedViewId);
const baseUrl = formattedUrl.href;
alert("Click to view this QuickSight shared view", baseUrl);
```
------
#### [ With the contentOptions SDK ]
Pass a `viewId` to the `contentOptions` to open the experience with the given `viewId`.
```
const contentOptions = {
toolbarOptions: {
...
},
viewId: sharedViewId,
};
const embeddedDashboard = await embeddingContext.embedDashboard(
{container: containerRef.current},
contentOptions
);
```
------
#### [ With the InitialPath property ]
```
const shareView = async() => {
const returnValue = await consoleFrame.createSharedView();
const {dashboardId, sharedViewId} = returnValue.message;
const newEmbedUrl = await generateNewEmbedUrl(`/dashboards/${dashboardId}/views/${sharedViewId}`);
setShareUrl(newEmbedUrl);
};
const generateNewEmbedUrl = async (initialPath) => {
const generateUrlPayload = {
experienceConfiguration: {
QuickSightConsole: {
InitialPath: initialPath,
FeatureConfigurations: {
"SharedView": {
"Enabled": true
},
},
},
}
const result: GenerateEmbedUrlResult = await generateEmbedUrlForRegisteredUser(generateUrlPayload);
return result.url;
};
```
------