### Installation

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

Instructions for installing the @sigmacomputing/react-embed-sdk package using npm, yarn, or pnpm.

```APIDOC
## Installation

To use the react-embed-sdk in your project, you can install it using your node package manager.

**Using npm:**

```bash
npm install @sigmacomputing/react-embed-sdk
```

**yarn:**

```bash
yarn add @sigmacomputing/react-embed-sdk
```

**pnpm:**

```bash
pnpm add @sigmacomputing/react-embed-sdk
```
```

--------------------------------

### Install @sigmacomputing/embed-sdk using pnpm

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/README.md

Installs the core Sigma Embed-SDK using pnpm. This package provides barebones wrappers over postMessages.

```bash
pnpm add @sigmacomputing/embed-sdk
```

--------------------------------

### Install @sigmacomputing/embed-sdk using yarn

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/README.md

Installs the core Sigma Embed-SDK using yarn. This package provides barebones wrappers over postMessages.

```bash
yarn add @sigmacomputing/embed-sdk
```

--------------------------------

### Install @sigmacomputing/embed-sdk using npm

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/README.md

Installs the core Sigma Embed-SDK using npm. This package provides barebones wrappers over postMessages.

```bash
npm install @sigmacomputing/embed-sdk
```

--------------------------------

### Install Sigma Embed SDK

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

Instructions for installing the Sigma Embed SDK using different package managers. This is the first step to integrating Sigma embeds into your React project.

```bash
npm install @sigmacomputing/react-embed-sdk
```

```bash
yarn add @sigmacomputing/react-embed-sdk
```

```bash
pnpm add @sigmacomputing/react-embed-sdk
```

--------------------------------

### Install @sigmacomputing/react-embed-sdk using pnpm

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/README.md

Installs the Sigma Embed-SDK for React using pnpm. This package provides React hooks for easy integration.

```bash
pnpm add @sigmacomputing/react-embed-sdk
```

--------------------------------

### Install Sigma Embed SDK using npm, yarn, or pnpm

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

Instructions for installing the Sigma Embed SDK using common Node.js package managers. This is the first step to integrating Sigma workbooks into your project.

```npm
npm install @sigmacomputing/embed-sdk
```

```yarn
yarn add @sigmacomputing/embed-sdk
```

```pnpm
pnpm add @sigmacomputing/embed-sdk
```

--------------------------------

### Install @sigmacomputing/react-embed-sdk using yarn

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/README.md

Installs the Sigma Embed-SDK for React using yarn. This package provides React hooks for easy integration.

```bash
yarn add @sigmacomputing/react-embed-sdk
```

--------------------------------

### Install @sigmacomputing/react-embed-sdk using npm

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/README.md

Installs the Sigma Embed-SDK for React using npm. This package provides React hooks for easy integration.

```bash
npm install @sigmacomputing/react-embed-sdk
```

--------------------------------

### Install Sigma Node.js Embed SDK

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/node-embed-sdk/README.md

Instructions for installing the Sigma Node.js Embed SDK using common Node.js package managers. This package provides utilities for interacting with Sigma's Embed API.

```bash
npm install @sigmacomputing/node-embed-sdk
```

```bash
yarn add @sigmacomputing/node-embed-sdk
```

```bash
pnpm add @sigmacomputing/node-embed-sdk
```

--------------------------------

### Control Fullscreen and Node Selection with React Embed SDK

Source: https://context7.com/sigmacomputing/embed-sdk/llms.txt

This example illustrates how to use the Sigma Embed SDK for React to toggle fullscreen mode for specific elements and navigate to different pages or elements within an embedded workbook. It relies on hooks to monitor fullscreen and selected node states and functions to trigger these actions. Dependencies include `@sigmacomputing/react-embed-sdk` and `react`.

```typescript
import {
  useSigmaIframe,
  updateWorkbookFullscreen,
  updateWorkbookSelectedNodeId,
  useWorkbookFullScreen,
  useWorkbookSelectedNode
} from "@sigmacomputing/react-embed-sdk";
import { useCallback, useState } from "react";

function NavigableEmbed() {
  const { iframeRef } = useSigmaIframe();
  const [isFullscreen, setIsFullscreen] = useState(false);
  const [currentNode, setCurrentNode] = useState<string | null>(null);

  useWorkbookFullScreen(iframeRef, useCallback((event) => {
    setIsFullscreen(event.fullScreen);
  }, []));

  useWorkbookSelectedNode(iframeRef, useCallback((event) => {
    setCurrentNode(event.selectedNodeId);
    console.log(`Now viewing ${event.nodeType}: ${event.selectedNodeId}`);
  }, []));

  const toggleFullscreenChart = (chartNodeId: string) => {
    if (!iframeRef.current) return;
    // Toggle fullscreen for specific chart element
    updateWorkbookFullscreen(iframeRef, isFullscreen ? null : chartNodeId);
  };

  const navigateToPage = (pageNodeId: string) => {
    if (!iframeRef.current) return;
    updateWorkbookSelectedNodeId(iframeRef, pageNodeId, "page");
  };

  const focusOnElement = (elementNodeId: string) => {
    if (!iframeRef.current) return;
    updateWorkbookSelectedNodeId(iframeRef, elementNodeId, "element");
  };

  return (
    <div>
      <nav>
        <button onClick={() => navigateToPage("page-overview")}>Overview</button>
        <button onClick={() => navigateToPage("page-details")}>Details</button>
        <button onClick={() => focusOnElement("chart-revenue")}>Revenue Chart</button>
        <button onClick={() => toggleFullscreenChart("chart-revenue")}>
          {isFullscreen ? "Exit Fullscreen" : "Fullscreen"}
        </button>
      </nav>
      <iframe ref={iframeRef} src="https://app.sigmacomputing.com/embed/1-multipage" />
    </div>
  );
}

```

--------------------------------

### Display Sigma Iframe with Loading and Error Handling (React/TSX)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/docs/basic-examples/app/examples/basic-example/page.mdx

This snippet shows a React component that uses the `useSigmaIframe` hook from the `@sigmacomputing/react-embed-sdk` to manage an embedded Sigma Computing iframe. It displays loading and error messages and controls the visibility of the iframe based on its state. It requires the `src` prop for the iframe URL.

```tsx
import { useSigmaIframe } from "@sigmacomputing/react-embed-sdk";

function BasicExample({ src }: { src: string }) {
  const { iframeRef, loading, error } = useSigmaIframe();
  return (
    <>
      <p className={loading ? "show" : "hidden"}> Loading...</p>
      <p className={error ? "show" : "hidden"}> Error loading iframe</p>
      <iframe
        src={src}
        ref={iframeRef}
        className={loading || error ? "hidden" : "show"}
        width={"100%"}
        height={"100%"}
      />
    </>
  );
}
```

--------------------------------

### Initialize Sigma Iframe with useSigmaIframe Hook

Source: https://context7.com/sigmacomputing/embed-sdk/llms.txt

The `useSigmaIframe` hook manages the lifecycle of an embedded Sigma workbook iframe, including loading states, error handling, and automatic setup of event listeners. It returns an iframe reference and relevant state variables. This hook is essential for integrating Sigma workbooks into React applications.

```typescript
import { useSigmaIframe } from "@sigmacomputing/react-embed-sdk";

function MyDashboard() {
  const { iframeRef, loading, error, variables } = useSigmaIframe();

  return (
    <div style={{ width: "100%", height: "600px" }}>
      {loading && <div>Loading your analytics dashboard...</div>}
      {error && (
        <div className="error-banner">
          Error: {error.message} (Code: {error.code})
        </div>
      )}
      <iframe
        ref={iframeRef}
        src="https://app.sigmacomputing.com/embed/1-abc123"
        style={{
          display: loading || error ? "none" : "block",
          width: "100%",
          height: "100%",
          border: "none"
        }}
      />
      {variables && (
        <div>Initial variables: {JSON.stringify(variables)}</div>
      )}
    </div>
  );
}
```

--------------------------------

### Low-Level Event Listeners (Vanilla JavaScript)

Source: https://context7.com/sigmacomputing/embed-sdk/llms.txt

Enables direct event listening for workbook events like loading, variable changes, and cell selection in non-React applications. This requires manual iframe referencing and event setup. It listens for messages posted from the iframe.

```typescript
import {
  workbookLoadedListener,
  workbookVariableChangeListener,
  workbookTableCellSelectListener
} from "@sigmacomputing/embed-sdk";

// Vanilla JavaScript implementation
const iframe = document.getElementById("sigma-embed") as HTMLIFrameElement;

window.addEventListener("message", (event: MessageEvent) => {
  // Workbook loaded
  workbookLoadedListener(event, iframe, (loadedEvent) => {
    console.log("Workbook loaded with variables:", loadedEvent.workbook.variables);
    document.getElementById("loading-spinner")?.remove();
  });

  // Variable changes
  workbookVariableChangeListener(event, iframe, (varEvent) => {
    console.log("Variables updated:", varEvent.workbook.variables);
    updateExternalFilters(varEvent.workbook.variables); // Assume updateExternalFilters is defined elsewhere
  });

  // Cell selection
  workbookTableCellSelectListener(event, iframe, (cellEvent) => {
    const selectedValues = cellEvent.cells.map(c => ({
      column: c.columnName,
      value: c.value
    }));
    displaySelection(selectedValues); // Assume displaySelection is defined elsewhere
  });
});
```

--------------------------------

### Encrypt/Decrypt OAuth Tokens with Node.js

Source: https://context7.com/sigmacomputing/embed-sdk/llms.txt

Server-side functions using `@sigmacomputing/node-embed-sdk` for encrypting and decrypting OAuth tokens with AES-256-GCM. It shows examples for generating embed URLs and handling webhook decryption. Requires `@sigmacomputing/node-embed-sdk`.

```typescript
import { encrypt, decrypt } from "@sigmacomputing/node-embed-sdk";

// Server-side route handler (Express example)
app.get("/api/embed-url", (req, res) => {
  const embedSecret = process.env.SIGMA_EMBED_SECRET;
  const userOAuthToken = getUserOAuthToken(req.user.id);

  // Encrypt the OAuth token
  const encryptedToken = encrypt(embedSecret, userOAuthToken);

  // Build embed URL with encrypted token
  const embedUrl = new URL("https://app.sigmacomputing.com/embed/1-workbook");
  embedUrl.searchParams.set(":token", encryptedToken);
  embedUrl.searchParams.set(":email", req.user.email);
  embedUrl.searchParams.set(":external_user_id", req.user.id);

  res.json({ embedUrl: embedUrl.toString() });
});

// Webhook handler for decrypting tokens
app.post("/api/sigma-webhook", (req, res) => {
  const embedSecret = process.env.SIGMA_EMBED_SECRET;
  const encryptedToken = req.body.token;

  try {
    const oauthToken = decrypt(embedSecret, encryptedToken);
    // Use the decrypted token to authenticate API calls
    const userData = await fetchUserData(oauthToken);
    res.json(userData);
  } catch (error) {
    console.error("Token decryption failed:", error);
    res.status(401).json({ error: "Invalid token" });
  }
});

```

--------------------------------

### Encrypt and Decrypt OAuth Tokens (Node.js)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/node-embed-sdk/README.md

Examples of encrypting and decrypting OAuth tokens using the Sigma Node.js Embed SDK. This functionality uses AES-256-GCM encryption and requires the same embed secret used for signing embeds. Supports both asynchronous and synchronous operations.

```typescript
import { encrypt, decrypt } from "@sigmacomputing/node-embed-sdk/promises";

// Encrypt an OAuth token
const encryptedToken = await encrypt("your-embed-secret", "your-oauth-token");

// Decrypt an encrypted token
const decryptedToken = await decrypt("your-embed-secret", encryptedToken);
```

```typescript
import { encrypt, decrypt } from "@sigmacomputing/node-embed-sdk";

// Encrypt an OAuth token
const encryptedToken = encrypt("your-embed-secret", "your-oauth-token");

// Decrypt an encrypted token
const decryptedToken = decrypt("your-embed-secret", encryptedToken);
```

--------------------------------

### useWorkbookVariables Hook

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `useWorkbookVariables` hook allows you to get and set workbook variables (filters) from your React application.

```APIDOC
## useWorkbookVariables Hook

A hook that returns functions to get and set the variables in a workbook.

### Parameters

- `iframeRef` (React.RefObject<HTMLIFrameElement>) - Required - A ref to the Sigma iframe element.

### Returns

- `getVariables` (): Promise<Record<string, string>> - A function that returns a promise resolving to the current workbook variables.
- `setVariables` (variables: Record<string, string>): void - A function to set the workbook variables.

### Example Usage

```tsx
import React from 'react';
import { useSigmaIframe, useWorkbookVariables } from '@sigmacomputing/react-embed-sdk';

function MyEmbed() {
  const { iframeRef } = useSigmaIframe();
  const { getVariables, setVariables } = useWorkbookVariables(iframeRef);

  const handleSetVariables = () => {
    setVariables({ foo: "bar" });
  };

  const handleGetVariables = async () => {
    const variables = await getVariables();
    console.log(variables);
  };

  return (
    <>
      <button onClick={handleSetVariables} name="set-variables">Set Filters</button>
      <button onClick={handleGetVariables} name="get-variables">Get Filters</button>
      <iframe ref={iframeRef} src="https://app.sigmacomputing.com/embed" />
    </>
  );
}
```
```

--------------------------------

### useWorkbookVariables Hook for Sigma Embed

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `useWorkbookVariables` hook allows you to get and set variables within a Sigma workbook via its iframe reference. This is useful for filtering or controlling workbook state programmatically.

```typescript
function MyEmbed() {
  const { getVariables, setVariables } = useWorkbookVariables(iframeRef);
  return (
    <>
      <button onClick={() => setVariables({ foo: "bar" }))} name="set-variables">Set Filters</button>
      <button
        onClick={async () => {
          const variable = await getVariables();
        }}
        name="get-variables"
      >
        Get Filters
      </button>
      <iframe ref={iframeRef} src="https://app.sigmacomputing.com/embed" />
    </>
  );
}
```

--------------------------------

### Build the Sigma Embed-SDK project

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/README.md

Builds all packages within the Sigma Embed-SDK repository using the pnpm build command. The repository contains 'embed-sdk', 'react-embed-sdk', and 'docs' packages.

```bash
pnpm run build
```

--------------------------------

### Manage Workbook Bookmarks with React Embed SDK

Source: https://context7.com/sigmacomputing/embed-sdk/llms.txt

This snippet demonstrates how to programmatically create, select, and delete workbook bookmarks using the Sigma Embed SDK for React. It utilizes hooks for bookmark creation and change events, and functions to interact with the embedded workbook. Dependencies include `@sigmacomputing/react-embed-sdk` and `react`.

```typescript
import {
  useSigmaIframe,
  createWorkbookBookmark,
  selectWorkbookBookmark,
  deleteWorkbookBookmark,
  useWorkbookBookmarkOnCreate,
  useWorkbookBookmarkOnChange
} from "@sigmacomputing/react-embed-sdk";
import type { WorkbookBookmarkOnCreateEvent } from "@sigmacomputing/react-embed-sdk";
import { useCallback, useState } from "react";

function BookmarkManager() {
  const { iframeRef } = useSigmaIframe();
  const [bookmarks, setBookmarks] = useState<string[]>([]);
  const [currentBookmark, setCurrentBookmark] = useState<string | null>(null);

  const handleBookmarkCreate = useCallback((event: WorkbookBookmarkOnCreateEvent) => {
    console.log("New bookmark created:", event.bookmarkName);
    console.log("Bookmark ID:", event.bookmarkId);
    setBookmarks(prev => [...prev, event.bookmarkId]);
  }, []);

  const handleBookmarkChange = useCallback((event) => {
    setCurrentBookmark(event.bookmarkId);
  }, []);

  useWorkbookBookmarkOnCreate(iframeRef, handleBookmarkCreate);
  useWorkbookBookmarkOnChange(iframeRef, handleBookmarkChange);

  const createNewBookmark = () => {
    if (!iframeRef.current) return;

    createWorkbookBookmark(iframeRef, {
      name: "Q4 2024 Report",
      isDefault: false,
      isShared: true
    });
  };

  const loadBookmark = (bookmarkId: string) => {
    if (!iframeRef.current) return;
    selectWorkbookBookmark(iframeRef, bookmarkId);
  };

  const removeBookmark = (bookmarkId: string) => {
    if (!iframeRef.current) return;
    deleteWorkbookBookmark(iframeRef, bookmarkId);
    setBookmarks(prev => prev.filter(id => id !== bookmarkId));
  };

  return (
    <div>
      <button onClick={createNewBookmark}>Save Current View</button>
      <div className="bookmark-list">
        {bookmarks.map(id => (
          <div key={id}>
            <button onClick={() => loadBookmark(id)}>Load</button>
            <button onClick={() => removeBookmark(id)}>Delete</button>
          </div>
        ))}
      </div>
      <iframe ref={iframeRef} src="https://app.sigmacomputing.com/embed/1-report" />
    </div>
  );
}

```

--------------------------------

### Get Workbook Variables Mutation (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `getWorkbookVariables` mutation sends a message to the embed to list the current variables. This action triggers a `workbook:variables:current` event, which can be captured using the `useWorkbookCurrentVariables` hook.

```typescript
getWorkbookVariables(iframeRef: React.RefObject<HTMLIFrameElement>)
```

--------------------------------

### Listen for Workbook Bookmark Create Event using TypeScript

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

This listener detects when a new bookmark is created within the embedded workbook. It executes a callback function, passing the bookmark creation event data and the iframe.

```typescript
workbookBookmarkCreateListener(event: MessageEvent, iframe: HTMLIFrameElement, onBookmarkCreate: (event: WorkbookBookmarkOnCreateEvent) => void)
```

--------------------------------

### Listen for Workbook Explore Key Change Events (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

Creates a listener to track changes in the workbook's explore key. It requires the iframe and a callback function to execute when the explore key changes. This is useful for dynamic adjustments based on user interaction within the explore view.

```typescript
workbookExploreKeyOnChangeListener(event: MessageEvent, iframe: HTMLIFrameElement, onExploreKeyOnChange: (event: WorkbookExploreKeyOnChangeEvent) => void)
```

--------------------------------

### Workbook Bookmark Listeners

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

Functions to listen for updates, deletes, and selections related to workbook bookmarks.

```APIDOC
## workbookBookmarkOnUpdateListener

### Description
Listen for a workbook bookmark update event, and execute the given callback when it occurs.

### Method
Listener

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```typescript
workbookBookmarkOnUpdateListener(event: MessageEvent, iframe: HTMLIFrameElement, onBookmarkUpdate: (event: WorkbookBookmarkOnUpdateEvent) => void)
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

```APIDOC
## workbookBookmarkOnDeleteListener

### Description
Listen for a workbook bookmark delete event, and execute the given callback when it occurs.

### Method
Listener

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```typescript
workbookBookmarkOnDeleteListener(event: MessageEvent, iframe: HTMLIFrameElement, onBookmarkDelete: (event: WorkbookBookmarkOnDeleteEvent) => void)
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Listen for Workbook Bookmark Create Event (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `useWorkbookBookmarkOnCreate` hook allows you to detect when a new bookmark is created in the workbook. The associated callback is invoked with `WorkbookBookmarkOnCreateEvent` details.

```typescript
useWorkbookBookmarkOnCreate(iframeRef: React.RefObject<HTMLIFrameElement>, onBookmarkCreate: (event: WorkbookBookmarkOnCreateEvent) => void)
```

--------------------------------

### Add a changeset for Sigma Embed-SDK

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/README.md

Generates a changeset file to manage versioning and publishing for the Sigma Embed-SDK packages. This command initiates an interactive prompt for changeset details.

```bash
pnpm changeset
```

--------------------------------

### Listen for Workbook Page Height Event using TypeScript

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

This listener captures changes in the embedded workbook's page height. It is intended for use with the `responsive_height` URL parameter and executes a callback with height information.

```typescript
workbookPageHeightListener(event: MessageEvent, iframe: HTMLIFrameElement, onPageHeight: (event: WorkbookPageHeightEvent) => void)
```

--------------------------------

### Listen for Workbook Explore Key Change Event (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

Use `useWorkbookExploreKeyOnChange` to listen for changes in the explore key within the workbook. The callback function receives `WorkbookExploreKeyOnChangeEvent` details.

```typescript
useWorkbookExploreKeyOnChange(iframeRef: React.RefObject<HTMLIFrameElement>, onExploreKeyOnChange: (event: WorkbookExploreKeyOnChangeEvent) => void)
```

--------------------------------

### Listen for Workbook Bookmark Update Events (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

Sets up a listener to detect when a workbook's bookmark is updated. It requires the iframe element and a callback function that will be executed upon the event. This listener is useful for synchronizing state or triggering actions when bookmark changes occur.

```typescript
workbookBookmarkOnUpdateListener(event: MessageEvent, iframe: HTMLIFrameElement, onBookmarkUpdate: (event: WorkbookBookmarkOnUpdateEvent) => void)
```

--------------------------------

### Listen for Workbook Bookmark Update Event (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `useWorkbookBookmarkOnUpdate` hook facilitates listening for updates applied to an existing workbook bookmark. The callback executes with `WorkbookBookmarkOnUpdateEvent` data.

```typescript
useWorkbookBookmarkOnUpdate(iframeRef: React.RefObject<HTMLIFrameElement>, onBookmarkUpdate: (event: WorkbookBookmarkOnUpdateEvent) => void)
```

--------------------------------

### Mutations: Workbook Sharing and Bookmarks

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

Functions to update sharing links, create, update, delete, and select bookmarks within a workbook.

```APIDOC
## workbookSharingLinkUpdate

### Description
Send a message to the embed to update the sharing link.

### Method
Mutation

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
- **sharingLink** (string | null) - Required - The new sharing link.
- **sharingExplorationLink** (string | null) - Optional - The new sharing exploration link.

### Request Example
```typescript
workbookSharingLinkUpdate(iframe: HTMLIFrameElement, sharingLink: string | null, sharingExplorationLink?: string | null)
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

```APIDOC
## workbookBookmarkCreate

### Description
Send a message to the embed to create a bookmark.

### Method
Mutation

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
- **bookmark** (WorkbookBookmarkCreateEvent) - Required - The bookmark data to create.

### Request Example
```typescript
workbookBookmarkCreate(iframe: HTMLIFrameElement, bookmark: WorkbookBookmarkCreateEvent)
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

```APIDOC
## workbookBookmarkUpdate

### Description
Send a message to the embed to update the current bookmark.

### Method
Mutation

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```typescript
workbookBookmarkUpdate(iframe: HTMLIFrameElement)
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

```APIDOC
## workbookBookmarkDelete

### Description
Send a message to the embed to delete the given bookmark.

### Method
Mutation

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
- **bookmarkId** (string) - Required - The ID of the bookmark to delete.

### Request Example
```typescript
workbookBookmarkDelete(iframe: HTMLIFrameElement, bookmarkId: string)
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

```APIDOC
## workbookBookmarkSelect

### Description
Send a message to the embed to select the given bookmark. If no bookmarkId is provided, the current bookmark will be deselected.

### Method
Mutation

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
- **bookmarkId** (string?) - Optional - The ID of the bookmark to select. If omitted, the current bookmark is deselected.

### Request Example
```typescript
workbookBookmarkSelect(iframe: HTMLIFrameElement, bookmarkId?: string)
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### useWorkbookFullScreen Listener for Sigma Embed

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `useWorkbookFullScreen` hook lets you listen for events related to the full-screen mode of a Sigma workbook. It requires an iframe ref and a full-screen event handler callback.

```typescript
useWorkbookFullScreen(iframeRef: React.RefObject<HTMLIFrameElement>, onFullScreen: (event: WorkbookFullScreenEvent) => void)
```

--------------------------------

### Listen for Workbook Bookmark Change Event (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

Use `useWorkbookBookmarkOnChange` to listen for any changes to the current bookmark in the workbook. The callback function will receive `WorkbookBookmarkOnChangeEvent` information.

```typescript
useWorkbookBookmarkOnChange(iframeRef: React.RefObject<HTMLIFrameElement>, onBookmarkChange: (event: WorkbookBookmarkOnChangeEvent) => void)
```

--------------------------------

### useSigmaIframe Hook

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `useSigmaIframe` hook provides a ref for a Sigma iframe element, along with its loading and error states.

```APIDOC
## useSigmaIframe Hook

A hook that returns a ref to be used with a Sigma iframe element, and the loading and error state of the embed.

### Returns

- `iframeRef` (React.RefObject<HTMLIFrameElement>): A ref object to attach to the iframe element.
- `loading` (boolean): Indicates if the iframe is currently loading.
- `error` (WorkbookErrorEvent | null): Contains error information if an error occurs during loading.
- `variables` (Record<string, string> | undefined): The current variables of the workbook.

### Example Usage

```tsx
import React from 'react';
import { useSigmaIframe } from '@sigmacomputing/react-embed-sdk';

function MyEmbed() {
  const { iframeRef, loading, error } = useSigmaIframe();

  return (
    <>
      {loading && <p>Loading...</p>}
      {error && <p>Error: {error.message}</p>}
      <iframe
        className={loading || error ? "hidden" : "show"}
        ref={iframeRef}
        src="https://app.sigmacomputing.com/embed"
      />
    </>
  );
}
```
```

--------------------------------

### Create Workbook Bookmark Mutation (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `createWorkbookBookmark` mutation sends a message to the embed to create a new bookmark. It requires an iframe reference and the bookmark details conforming to `WorkbookBookmarkCreateEvent`.

```typescript
createWorkbookBookmark(iframeRef: React.RefObject<HTMLIFrameElement>, bookmark: WorkbookBookmarkCreateEvent)
```

--------------------------------

### Low-Level Mutation Functions (Vanilla JavaScript)

Source: https://context7.com/sigmacomputing/embed-sdk/llms.txt

Provides direct functions to control embedded Sigma workbooks, such as updating variables, toggling fullscreen mode for charts, and creating bookmarks. These functions are intended for use in vanilla JavaScript applications without React hooks.

```typescript
import {
  workbookVariablesUpdate,
  workbookFullscreenUpdate,
  workbookBookmarkCreate
} from "@sigmacomputing/embed-sdk";

// Update variables
document.getElementById("apply-filters")?.addEventListener("click", () => {
  const iframe = document.getElementById("sigma-embed") as HTMLIFrameElement;

  workbookVariablesUpdate(iframe, {
    start_date: "2024-01-01",
    end_date: "2024-12-31",
    region: "APAC"
  });
});

// Toggle fullscreen
document.getElementById("fullscreen-btn")?.addEventListener("click", () => {
  const iframe = document.getElementById("sigma-embed") as HTMLIFrameElement;
  const chartId = "chart-123";
  const isFullscreen = document.fullscreenElement !== null;

  workbookFullscreenUpdate(iframe, isFullscreen ? null : chartId);
});

// Create bookmark
document.getElementById("save-view")?.addEventListener("click", () => {
  const iframe = document.getElementById("sigma-embed") as HTMLIFrameElement;

  workbookBookmarkCreate(iframe, {
    name: "Year End Report",
    isDefault: false,
    isShared: true
  });
});
```

--------------------------------

### Track Workbook Page Height for Responsive Iframes (React)

Source: https://context7.com/sigmacomputing/embed-sdk/llms.txt

Uses the `useWorkbookPageHeight` hook to dynamically adjust iframe height based on workbook content. It listens for page height changes and updates the iframe's style. Requires `@sigmacomputing/react-embed-sdk`.

```typescript
import { useWorkbookPageHeight, useSigmaIframe } from "@sigmacomputing/react-embed-sdk";
import type { WorkbookPageHeightEvent } from "@sigmacomputing/react-embed-sdk";
import { useCallback, useState, useEffect } from "react";

function ResponsiveEmbed() {
  const { iframeRef } = useSigmaIframe();
  const [iframeHeight, setIframeHeight] = useState(600);

  const handlePageHeightChange = useCallback((event: WorkbookPageHeightEvent) => {
    console.log("Page height changed:", event.pageHeight);
    // Add buffer for padding and scrollbars
    setIframeHeight(event.pageHeight + 20);
  }, []);

  useWorkbookPageHeight(iframeRef, handlePageHeightChange);

  return (
    <iframe
      ref={iframeRef}
      src="https://app.sigmacomputing.com/embed/1-report"
      style={{
        width: "100%",
        height: `${iframeHeight}px`,
        border: "none",
        transition: "height 0.3s ease"
      }}
    />
  );
}

```

--------------------------------

### usePageHeight Hook

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `usePageHeight` hook retrieves the current height of the content within the iframe, intended for use with the `responsive_height` URL parameter.

```APIDOC
## usePageHeight Hook

A hook that returns the height of the page in the iframe. This HAS to be used with the `responsive_height` [URL Parameter](https://help.sigmacomputing.com/docs/embed-url-parameters).

### Parameters

- `iframeRef` (React.RefObject<HTMLIFrameElement>) - Required - A ref to the Sigma iframe element.

### Returns

- `height` (number | undefined): The current height of the content in the iframe, or undefined if not yet available.

### Example Usage

```tsx
import React from 'react';
import { useSigmaIframe, usePageHeight } from '@sigmacomputing/react-embed-sdk';

function MyEmbed() {
  const { iframeRef } = useSigmaIframe();
  const height = usePageHeight(iframeRef);

  return (
    <>
      <iframe
        style={{ height }}
        ref={iframeRef}
        src="https://app.sigmacomputing.com/embed?:responsive_height=true"
      />
    </>
  );
}
```
```

--------------------------------

### Listen for Workbook Published Event using TypeScript

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

This listener is triggered when a workbook is published. It allows you to execute a callback function upon successful publication, providing the event details and the iframe.

```typescript
workbookPublishedListener(event: MessageEvent, iframe: HTMLIFrameElement, onPublished: (event: WorkbookPublishedEvent) => void)
```

--------------------------------

### Create Workbook Bookmark (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

Sends a message to create a new bookmark within the embedded workbook. This function requires the iframe element and the bookmark details. It allows users or applications to save the current state of the workbook as a bookmark.

```typescript
workbookBookmarkCreate(iframe: HTMLIFrameElement, bookmark: WorkbookBookmarkCreateEvent)
```

--------------------------------

### Event Listeners

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

A collection of hooks to listen for various events emitted by the Sigma embed, allowing your application to react to workbook states and user interactions.

```APIDOC
## Listeners

These are functions that can be used to listen for events from the embed, and react to them.

### `useWorkbookLoaded`

Listen for a workbook loaded event, and execute the given callback when it occurs.

```typescript
useWorkbookLoaded(iframeRef: React.RefObject<HTMLIFrameElement>, onLoaded: (event: WorkbookLoadedEvent) => void)
```

### `useWorkbookError`

Listen for a workbook error event, and execute the given callback when it occurs.

```typescript
useWorkbookError(iframeRef: React.RefObject<HTMLIFrameElement>, onError: (event: WorkbookErrorEvent) => void)
```

### `useWorkbookDataLoaded`

Listen for a workbook data loaded event, and execute the given callback when it occurs.

```typescript
useWorkbookDataLoaded(iframeRef: React.RefObject<HTMLIFrameElement>, onDataLoaded: (event: WorkbookDataLoadedEvent) => void)
```

### `useVariableChange`

Listen for a workbook variable change event, and execute the given callback when it occurs.

```typescript
useVariableChange(iframeRef: React.RefObject<HTMLIFrameElement>, onVariableChange: (event: WorkbookVariableOnChangeEvent) => void)
```

### `useTableCellSelect`

Listen for a table cell select event, and execute the given callback when it occurs.

```typescript
useTableCellSelect(iframeRef: React.RefObject<HTMLIFrameElement>, onTableCellSelect: (event: WorkbookTableCellSelectEvent) => void)
```

### `useWorkbookPublished`

Listen for a workbook published event, and execute the given callback when it occurs.

```typescript
useWorkbookPublished(iframeRef: React.RefObject<HTMLIFrameElement>, onWorkbookPublished: (event: WorkbookPublishedEvent) => void)
```

### `useWorkbookFullScreen`

Listen for a workbook full screen event, and execute the given callback when it occurs.

```typescript
useWorkbookFullScreen(iframeRef: React.RefObject<HTMLIFrameElement>, onFullScreen: (event: WorkbookFullScreenEvent) => void)
```

### `useWorkbookPageHeight`

Listen for a workbook page height event, and execute the given callback when it occurs. Needs to be used with the `responsive_height` [URL Parameter](https://help.sigmacomputing.com/docs/embed-url-parameters).

```typescript
useWorkbookPageHeight(iframeRef: React.RefObject<HTMLIFrameElement>, onPageHeight: (event: WorkbookPageHeightEvent) => void)
```
```

--------------------------------

### useWorkbookPageHeight Listener for Sigma Embed

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `useWorkbookPageHeight` hook listens for page height updates from a Sigma workbook, typically used with the `responsive_height` URL parameter. It takes an iframe ref and a page height callback.

```typescript
useWorkbookPageHeight(iframeRef: React.RefObject<HTMLIFrameElement>, onPageHeight: (event: WorkbookPageHeightEvent) => void)
```

--------------------------------

### Listen for Workbook Data Loaded Events (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

Configures a listener to be notified when the data for a workbook has been loaded. It requires the iframe element and a callback function that processes the loaded data event. This is crucial for ensuring subsequent operations are performed only after the data is available.

```typescript
workbookDataLoadedListener(event: MessageEvent, iframe: HTMLIFrameElement, onWorkbookDataLoaded: (event: WorkbookDataLoadedEvent) => void)
```

--------------------------------

### Listen for Workbook Bookmark Change Event using TypeScript

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

This function allows you to listen for changes made to existing bookmarks in the embedded workbook. It executes a callback with the bookmark change event data and the iframe.

```typescript
workbookBookmarkOnChangeListener(event: MessageEvent, iframe: HTMLIFrameElement, onBookmarkChange: (event: WorkbookBookmarkOnChangeEvent) => void)
```

--------------------------------

### Listen for Workbook Full Screen Event using TypeScript

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

Detect when the embedded workbook enters or exits full-screen mode. This listener executes a callback with the relevant event data and the iframe element.

```typescript
workbookFullScreenListener(event: MessageEvent, iframe: HTMLIFrameElement, onFullScreen: (event: WorkbookFullScreenEvent) => void)
```

--------------------------------

### useWorkbookLoaded Listener for Sigma Embed

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `useWorkbookLoaded` hook allows you to execute a callback function when a Sigma workbook has finished loading within the iframe. It takes an iframe ref and a callback function as arguments.

```typescript
useWorkbookLoaded(iframeRef: React.RefObject<HTMLIFrameElement>, onLoaded: (event: WorkbookLoadedEvent) => void)
```

--------------------------------

### usePageHeight Hook for Responsive Sigma Embeds

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `usePageHeight` hook retrieves the height of a Sigma workbook's page within an iframe. It must be used in conjunction with the `responsive_height` URL parameter for proper functionality.

```typescript
function MyEmbed() {
  const { iframeRef } = useSigmaIframe();
  const height = usePageHeight(iframeRef);
  return (
    <>
      <iframe
        style={{ height }}
        ref={iframeRef}
        src="https://app.sigmacomputing.com/embed?:responsive_height=true"
      />
    </>
  );
}
```

--------------------------------

### useSigmaIframe Hook for Sigma Embed

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `useSigmaIframe` hook provides a ref for a Sigma iframe element and manages its loading and error states. It's essential for interacting with Sigma embeds.

```typescript
function MyEmbed() {
  const { iframeRef, loading, error } = useSigmaIframe();
  return (
    <>
      {loading && <p>Loading...</p>}
      {error && <p>Error: {error.message}</p>}
      <iframe
        className={loading || error ? "hidden" : "show"}
        ref={iframeRef}
        src="https://app.sigmacomputing.com/embed"
      />
    </>
  );
}
```

--------------------------------

### Listen for Workbook Bookmark Delete Events (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

Establishes a listener for when a workbook bookmark is deleted. It takes the iframe element and a callback function to execute when the delete event is detected. This is helpful for managing local state or UI updates related to deleted bookmarks.

```typescript
workbookBookmarkOnDeleteListener(event: MessageEvent, iframe: HTMLIFrameElement, onBookmarkDelete: (event: WorkbookBookmarkOnDeleteEvent) => void)
```

--------------------------------

### Mutations: Workbook UI Control

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

Functions to control the workbook's UI, such as toggling fullscreen and updating selected nodes.

```APIDOC
## workbookFullscreenUpdate

### Description
Send a message to the embed to toggle the fullscreen state of the given element.

### Method
Mutation

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
- **nodeId** (string | null) - Required - The ID of the element to put into fullscreen. If null, exits fullscreen.

### Request Example
```typescript
workbookFullscreenUpdate(iframe: HTMLIFrameElement, nodeId: string | null)
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

```APIDOC
## workbookSelectedNodeIdUpdate

### Description
Send a message to the embed to update the selected element. Can be a pageId or elementId.

### Method
Mutation

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
- **nodeId** (string) - Required - The ID of the element or page to select.
- **nodeType** ("element" | "page") - Required - The type of the node to select.

### Request Example
```typescript
workbookSelectedNodeIdUpdate(iframe: HTMLIFrameElement, nodeId: string, nodeType: "element" | "page")
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Select Workbook Bookmark Mutation (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/react-embed-sdk/README.md

The `selectWorkbookBookmark` mutation allows you to select a specific bookmark by providing its ID. If no `bookmarkId` is provided, the current bookmark will be deselected. It requires an iframe reference.

```typescript
selectWorkbookBookmark(iframeRef: React.RefObject<HTMLIFrameElement>, bookmarkId?: string)
```

--------------------------------

### Track Workbook Load with useWorkbookLoaded (TypeScript)

Source: https://context7.com/sigmacomputing/embed-sdk/llms.txt

The `useWorkbookLoaded` hook executes a callback function once an embedded Sigma workbook has successfully loaded. It provides an event object containing details about the workbook, including initial variable values. This is useful for performance monitoring, triggering subsequent actions after load, or capturing initial workbook state. It requires the `iframeRef` and a handler function.

```typescript
import { useWorkbookLoaded, useSigmaIframe } from "@sigmacomputing/react-embed-sdk";
import type { WorkbookLoadedEvent } from "@sigmacomputing/react-embed-sdk";
import { useCallback, useState, useRef } from "react";

function TrackingDashboard() {
  const { iframeRef } = useSigmaIframe();
  const [loadTime, setLoadTime] = useState<number | null>(null);
  const startTime = useRef(Date.now());

  const handleLoaded = useCallback((event: WorkbookLoadedEvent) => {
    const elapsed = Date.now() - startTime.current;
    setLoadTime(elapsed);

    console.log("Workbook loaded successfully");
    console.log("Initial variables:", event.workbook.variables);

    // Send analytics event
    analytics.track("workbook_loaded", {
      loadTimeMs: elapsed,
      variables: event.workbook.variables
    });
  }, []);

  useWorkbookLoaded(iframeRef, handleLoaded);

  return (
    <div>
      {loadTime && <div>Loaded in {loadTime}ms</div>}
      <iframe ref={iframeRef} src="https://app.sigmacomputing.com/embed/1-report" />
    </div>
  );
}

```

--------------------------------

### Async OAuth Token Encryption (Node.js)

Source: https://context7.com/sigmacomputing/embed-sdk/llms.txt

Provides promise-based encryption and decryption functions for securely handling OAuth tokens within async/await workflows in Node.js. It requires an embed secret configured in the environment variables.

```typescript
import { encryptAsync, decryptAsync } from "@sigmacomputing/node-embed-sdk/promises";

async function generateEmbedUrl(userId: string): Promise<string> {
  const embedSecret = process.env.SIGMA_EMBED_SECRET;
  const userOAuthToken = await fetchOAuthToken(userId); // Assume fetchOAuthToken is defined elsewhere

  try {
    const encryptedToken = await encryptAsync(embedSecret, userOAuthToken);

    const embedUrl = new URL("https://app.sigmacomputing.com/embed/1-dashboard");
    embedUrl.searchParams.set(":token", encryptedToken);
    embedUrl.searchParams.set(":email", await getUserEmail(userId)); // Assume getUserEmail is defined elsewhere
    embedUrl.searchParams.set(":account_type", "viewer");

    return embedUrl.toString();
  } catch (error) {
    console.error("Failed to encrypt token:", error);
    throw new Error("Unable to generate embed URL");
  }
}

async function validateEmbedToken(encryptedToken: string): Promise<boolean> {
  const embedSecret = process.env.SIGMA_EMBED_SECRET;

  try {
    const oauthToken = await decryptAsync(embedSecret, encryptedToken);
    const isValid = await verifyOAuthToken(oauthToken); // Assume verifyOAuthToken is defined elsewhere
    return isValid;
  } catch (error) {
    console.error("Token validation failed:", error);
    return false;
  }
}
```

--------------------------------

### Listen for Workbook Loaded Event using TypeScript

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

This function allows you to listen for the 'workbookLoaded' event from an embedded Sigma workbook. It executes a provided callback function once the workbook has finished loading, passing relevant event data and the iframe element.

```typescript
workbookLoadedListener(event: MessageEvent, iframe: HTMLIFrameElement, onLoaded: (event: WorkbookLoadedEvent) => void)
```

--------------------------------

### Listen for URL Change Events (TypeScript)

Source: https://github.com/sigmacomputing/embed-sdk/blob/main/packages/embed-sdk/README.md

Implements a listener for changes in the workbook's URL. It takes the iframe element and a callback function to be invoked when the URL is updated. This can be used for deep linking or tracking navigation within the embedded workbook.

```typescript
urlOnChangeListener(event: MessageEvent, iframe: HTMLIFrameElement, onUrlChange: (event: UrlOnChangeEvent) => void)
```

--------------------------------

### useWorkbookPivotTableCellSelect Hook

Source: https://context7.com/sigmacomputing/embed-sdk/llms.txt

Handles clicks on pivot table cells, providing row and column path context for detailed analysis.

```APIDOC
## Pivot Table Cell Selection

### Description
Handles clicks on pivot table cells, providing row and column path context for detailed analysis.

### Method
`useWorkbookPivotTableCellSelect(iframeRef, callback)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```typescript
import { useWorkbookPivotTableCellSelect } from "@sigmacomputing/react-embed-sdk";
import type { WorkbookPivotTableCellSelectEvent } from "@sigmacomputing/react-embed-sdk";
import { useCallback, useRef } from "react";

function PivotTableAnalysis() {
  const iframeRef = useRef<HTMLIFrameElement>(null);

  const handlePivotCellSelect = useCallback((event: WorkbookPivotTableCellSelectEvent) => {
    event.cells.forEach(cell => {
      console.log(`Cell value: ${cell.value}`);
      console.log(`Column: ${cell.columnName}, Type: ${cell.cellType}`);
      if (cell.rowPath) {
        console.log("Row path:", cell.rowPath.map(p => `${p.name}=${p.value}`));
      }
      if (cell.columnPath) {
        console.log("Column path:", cell.columnPath.map(p => `${p.name}=${p.value}`));
      }
    });
  }, []);

  useWorkbookPivotTableCellSelect(iframeRef, handlePivotCellSelect);

  return <iframe ref={iframeRef} src="https://app.sigmacomputing.com/embed/1-pivot" />;
}
```

### Response
#### Success Response (Callback)
- **event** (WorkbookPivotTableCellSelectEvent) - An object containing details about the pivot table cell selection, including an array of selected cells with their values and path context.

#### Response Example
```json
{
  "cells": [
    {
      "value": 50000,
      "columnName": "Sales",
      "cellType": "Data",
      "rowPath": [
        {"name": "Region", "value": "West"},
        {"name": "State", "value": "California"}
      ],
      "columnPath": [
        {"name": "Metric", "value": "Sales"}
      ]
    }
  ]
}
```
```