@cube-dev/platform-client 0.7.0 → 0.9.0

package/dist/schema.d.ts

@@ -381,6 +381,88 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/deployments/{deploymentId}/databricks-metric-view-integrations/{dataSourceName}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Databricks Metric View publication settings
+         * @description Requires a Databricks datasource. This is currently in preview — reach out to the Cube support team to activate it for your account.
+         */
+        get: operations["DatabricksMetricViewIntegrationPublicController.getIntegration"];
+        /**
+         * Create or update Databricks Metric View publication settings
+         * @description Uses optimistic configuration versioning. Pass `expectedConfigurationVersion` 0 to create. Requires a Databricks datasource. This is currently in preview — reach out to the Cube support team to activate it for your account.
+         */
+        put: operations["DatabricksMetricViewIntegrationPublicController.saveIntegration"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/deployments/{deploymentId}/databricks-metric-view-previews": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start a Databricks Metric View publication preview
+         * @description Queues an offline conversion of static YAML from the deployment's latest successful build and returns polling URLs immediately. Exact retries while the same content-addressed preview is running reuse that work; a later submission starts a fresh execution. Preview payloads and results are retained for at most seven days. The conversion supports scalar dimensions, common and calculated measures, and acyclic many-to-one equi-joins from one Databricks datasource. Access policies, templating, extends, unsafe fanout, unsupported expressions, multiple datasources, and converter loss are blocked per view. Two-part schema.table sources are qualified with `CUBEJS_DB_DATABRICKS_CATALOG` for the selected datasource; without that setting they fail closed with an actionable issue. Requires `SchemaRead` or `SchemaUpdate` access. This is currently in preview — reach out to the Cube support team to activate it for your account.
+         */
+        post: operations["DatabricksMetricViewPublicationPublicController.startPreview"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/deployments/{deploymentId}/databricks-metric-view-previews/{previewId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get Databricks Metric View preview status */
+        get: operations["DatabricksMetricViewPublicationPublicController.previewStatus"];
+        put?: never;
+        post?: never;
+        /** Cancel a Databricks Metric View preview */
+        delete: operations["DatabricksMetricViewPublicationPublicController.cancelPreview"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/deployments/{deploymentId}/databricks-metric-view-previews/{previewId}/result": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a completed Databricks Metric View preview result
+         * @description Returns 409 while the preview is still running or if it ended without a conversion result.
+         */
+        get: operations["DatabricksMetricViewPublicationPublicController.previewResult"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/deployments/{deploymentId}/dbt-sync": {
         parameters: {
             query?: never;
@@ -451,6 +533,36 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/deployments/{deploymentId}/embed-tenants/{embedTenantName}/workbooks": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List workbooks accessible to an embed tenant
+         * @description **🔒 Admin only.** Requires administrator privileges — the authenticated principal (API key, embed JWT, or any bearer token) must belong to a user with the admin role.
+         *
+         *     Return every workbook the named embed tenant can access in this deployment. Effective access includes workbooks shared directly with the tenant, workbooks shared with all embed users, and workbooks inherited from shared folders. Supports `first`/`after` cursor pagination.
+         *
+         *     Filter workbooks by how access is granted:
+         *
+         *     - `tenant`: the workbook itself is explicitly shared with the named embed tenant. Excludes workbooks available only through the all-embed-users group or a shared folder.
+         *     - `allEmbedUsers`: the workbook itself is explicitly shared with the built-in all-embed-users group, making it available to every embed tenant. Excludes tenant-specific direct shares and folder-inherited access.
+         *     - `folder`: access is inherited because the workbook is inside a shared folder or any of its descendant folders. The folder may be shared specifically with the named tenant or with all embed users.
+         *
+         *     Omit this parameter to return the union of all three access sources. A workbook can match more than one source.
+         */
+        get: operations["DashboardEmbedAccessPublicController.listEmbedTenantWorkbooks"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/deployments/{deploymentId}/env-vars": {
         parameters: {
             query?: never;
@@ -1565,6 +1677,112 @@ export interface paths {
         patch: operations["EmbedPublicController.updateDashboardEmbedding"];
         trace?: never;
     };
+    "/api/v1/embed/dashboard/{publicId}/comments": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List comment threads on an embeddable dashboard
+         * @description Returns one page of comment threads — each a root comment plus its replies, oldest first — for the dashboard identified by its `publicId`, scoped to the caller's embed tenant.
+         *
+         *     Threads are ordered newest-first by when they started, so a thread holds its place while it is being replied to. Open threads are returned by default; pass `includeResolved` to widen the page to resolved ones too, or `resolvedOnly` to replace the set with just those.
+         *
+         *     A comment whose author deleted it is returned with an empty `body` and `removedAt` set, so a thread keeps its shape and the surviving replies stay readable.
+         *
+         *     Requires a signed embed session scoped to an embed tenant. Every comment endpoint does: a conversation lives inside one embed tenant's partition, so a credential that names no tenant — an API key, a console session — has no conversation to be served and receives `403`.
+         */
+        get: operations["EmbedPublicController.listDashboardComments"];
+        put?: never;
+        /**
+         * Post a comment on an embeddable dashboard
+         * @description Starts a thread, or replies to one when `parentId` names a thread root.
+         *
+         *     The comment is attributed to the calling embed user — the author is taken from the signed session, never from the request body. Nesting is one level deep: replying to a reply returns `400`, and `404` covers a `parentId` that names a comment on another dashboard, a deleted thread, or nothing at all.
+         */
+        post: operations["EmbedPublicController.createDashboardComment"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/embed/dashboard/{publicId}/comments/mentionable-users": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List embed users mentionable in a dashboard comment
+         * @description Returns one page of the caller's fellow embed users, for a mention autocomplete, ordered by username.
+         *
+         *     Scoped to the caller's own embed tenant and to embed users only — console users of the host tenant are never returned. Pass `search` to filter by username or email. `email` may be `null`: `username` is the only identity field an embed user is guaranteed to have.
+         */
+        get: operations["EmbedPublicController.listMentionableEmbedUsers"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/embed/dashboard/{publicId}/comments/{commentId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Delete a comment on an embeddable dashboard
+         * @description Soft-deletes a comment. Author only.
+         *
+         *     Deleting a thread root takes its replies with it, so a deleted thread leaves nothing behind. Deleting a reply re-derives its thread's last-activity marker, so the thread does not keep its position on the strength of a message that is gone.
+         */
+        delete: operations["EmbedPublicController.removeDashboardComment"];
+        options?: never;
+        head?: never;
+        /**
+         * Edit a comment on an embeddable dashboard
+         * @description Replaces a comment's body and stamps `editedAt`.
+         *
+         *     Author only: another embed user's comment returns `403`, and a comment that is not on this dashboard returns `404` rather than revealing that it exists elsewhere.
+         */
+        patch: operations["EmbedPublicController.updateDashboardComment"];
+        trace?: never;
+    };
+    "/api/v1/embed/dashboard/{publicId}/comments/{commentId}/resolve": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Resolve or re-open a comment thread
+         * @description Marks a thread resolved, or re-opens it. Author only — the embed user who started the thread.
+         *
+         *     The console surface is wider: there, a workbook editor may also resolve someone else's thread. That branch has no analogue here, because an embed viewer holds no workbook rights at all, so authorship is the whole rule.
+         *
+         *     Threads only — a reply has no resolve state of its own, and one carrying it would put two answers on the same thread, so `400` is returned for a reply's id. A thread whose root was deleted while replies survive is still resolvable, or it would sit in the unresolved list forever.
+         */
+        post: operations["EmbedPublicController.setDashboardCommentResolved"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/embed/dashboard/{publicId}/python-run": {
         parameters: {
             query?: never;
@@ -2818,6 +3036,7 @@ export interface components {
             applyThemeGlobally: boolean;
             creatorMode?: components["schemas"]["CreatorMode"] | null;
             embedding?: components["schemas"]["EmbedSettings"] | null;
+            sheetsAgentChatEnabled: boolean;
             sheetsUi?: components["schemas"]["SheetsUiSettings"] | null;
             timezoneSettings?: components["schemas"]["TimezoneSettings"] | null;
         };
@@ -3050,6 +3269,10 @@ export interface components {
         CreateDeploymentTokenInput: {
             expiresIn?: number | null;
         };
+        CreateEmbedDashboardCommentBody: {
+            body: string;
+            parentId?: number | null;
+        };
         CreateEmbedGroupInput: {
             description?: string | null;
             /** @description Group name, unique within the embed tenant. The `system:` prefix is reserved and rejected. */
@@ -3486,6 +3709,153 @@ export interface components {
         DataModelWriteResponse: {
             success: boolean;
         };
+        DatabricksMetricViewIntegrationConfigurationResponse: {
+            deletionPolicy: components["schemas"]["DatabricksMetricViewIntegrationConfigurationResponseDeletionPolicy"];
+            enabled: boolean;
+            selectionMode: components["schemas"]["DatabricksMetricViewIntegrationConfigurationResponseSelectionMode"];
+            sourceOverrides?: {
+                [key: string]: string;
+            } | null;
+            targetCatalog: string;
+            targetNamePrefix?: string | null;
+            targetNames?: {
+                [key: string]: string;
+            } | null;
+            targetSchema: string;
+            version: components["schemas"]["DatabricksMetricViewIntegrationConfigurationResponseVersion"];
+            viewNameRegex?: string | null;
+            viewNames?: string[] | null;
+        };
+        /** @enum {string} */
+        DatabricksMetricViewIntegrationConfigurationResponseDeletionPolicy: "retain" | "delete-managed";
+        /** @enum {string} */
+        DatabricksMetricViewIntegrationConfigurationResponseSelectionMode: "all" | "selected" | "pattern";
+        /** @enum {number} */
+        DatabricksMetricViewIntegrationConfigurationResponseVersion: 1;
+        DatabricksMetricViewIntegrationResponse: {
+            accessTest?: Record<string, never> | null;
+            configuration: components["schemas"]["DatabricksMetricViewIntegrationConfigurationResponse"];
+            configurationVersion: number;
+            createdAt: string;
+            dataSourceName: string;
+            deploymentId: number;
+            publicId: string;
+            updatedAt: string;
+        };
+        DatabricksMetricViewPublicationCounts: {
+            dimensions: number;
+            errors: number;
+            joins: number;
+            measures: number;
+            warnings: number;
+        };
+        DatabricksMetricViewPublicationDatasetSource: {
+            dataSource: string;
+            dataset: string;
+            originalSource: string;
+            resolvedSource: string;
+        };
+        DatabricksMetricViewPublicationIssue: {
+            code: string;
+            element?: string | null;
+            message: string;
+            severity: components["schemas"]["DatabricksMetricViewPublicationIssueSeverity"];
+            stage: components["schemas"]["DatabricksMetricViewPublicationIssueStage"];
+        };
+        /** @enum {string} */
+        DatabricksMetricViewPublicationIssueSeverity: "ERROR" | "WARNING";
+        /** @enum {string} */
+        DatabricksMetricViewPublicationIssueStage: "INPUT" | "VIEW_PROJECTION" | "OSSIE_VALIDATION" | "OSSIE_TO_DATABRICKS" | "OUTPUT_VALIDATION" | "EXECUTION";
+        DatabricksMetricViewPublicationPreviewInput: {
+            dataSourceName: string;
+            selectionMode: components["schemas"]["DatabricksMetricViewPublicationPreviewInputSelectionMode"];
+            sourceOverrides?: {
+                [key: string]: string;
+            } | null;
+            targetNames?: {
+                [key: string]: string;
+            } | null;
+            viewNameRegex?: string | null;
+            viewNames?: string[] | null;
+        };
+        /** @enum {string} */
+        DatabricksMetricViewPublicationPreviewInputSelectionMode: "all" | "selected" | "pattern";
+        DatabricksMetricViewPublicationPreviewResultResponse: {
+            buildJobId: number;
+            commit?: string | null;
+            completedAt: string;
+            dataSourceName: string;
+            deploymentId: number;
+            durationMs: number;
+            outcome: components["schemas"]["DatabricksMetricViewPublicationPreviewResultResponseOutcome"];
+            previewId: string;
+            runtime: components["schemas"]["DatabricksMetricViewPublicationRuntime"];
+            sourceSha256: string;
+            version: components["schemas"]["DatabricksMetricViewPublicationPreviewResultResponseVersion"];
+            views: components["schemas"]["DatabricksMetricViewPublicationViewResult"][];
+        };
+        /** @enum {string} */
+        DatabricksMetricViewPublicationPreviewResultResponseOutcome: "success" | "partial" | "failed";
+        /** @enum {integer} */
+        DatabricksMetricViewPublicationPreviewResultResponseVersion: 2;
+        DatabricksMetricViewPublicationPreviewStartResponse: {
+            buildJobId: number;
+            commit?: string | null;
+            dataSourceName: string;
+            deploymentId: number;
+            previewId: string;
+            resultUrl: string;
+            reused: boolean;
+            status: components["schemas"]["DatabricksMetricViewPublicationPreviewStartResponseStatus"];
+            statusUrl: string;
+        };
+        /** @enum {string} */
+        DatabricksMetricViewPublicationPreviewStartResponseStatus: "QUEUED";
+        DatabricksMetricViewPublicationPreviewStatusResponse: {
+            dataSourceName: string;
+            deploymentId: number;
+            error?: string | null;
+            previewId: string;
+            progress: components["schemas"]["DatabricksMetricViewPublicationProgress"];
+            resultAvailable: boolean;
+            startedAt: string;
+            status: components["schemas"]["DatabricksMetricViewPublicationPreviewStatusResponseStatus"];
+            updatedAt: string;
+        };
+        /** @enum {string} */
+        DatabricksMetricViewPublicationPreviewStatusResponseStatus: "QUEUED" | "RUNNING" | "COMPLETED" | "FAILED" | "CANCELLED";
+        DatabricksMetricViewPublicationProgress: {
+            message: string;
+            percentComplete: number;
+            stage: components["schemas"]["DatabricksMetricViewPublicationProgressStage"];
+        };
+        /** @enum {string} */
+        DatabricksMetricViewPublicationProgressStage: "QUEUED" | "RUNNING" | "COMPLETED" | "FAILED" | "CANCELLED";
+        DatabricksMetricViewPublicationRuntime: {
+            bridgeCommit: string;
+            bridgeVersion: string;
+            cubeConverterVersion: string;
+            databricksConverterVersion: string;
+            ossieCommit: string;
+            ossieCoreVersion: string;
+            policyVersion: number;
+            runnerVersion: string;
+            templateName: string;
+        };
+        DatabricksMetricViewPublicationViewResult: {
+            counts: components["schemas"]["DatabricksMetricViewPublicationCounts"];
+            cubeViewName: string;
+            datasetSources: components["schemas"]["DatabricksMetricViewPublicationDatasetSource"][];
+            eligibleForPublication: boolean;
+            issues: components["schemas"]["DatabricksMetricViewPublicationIssue"][];
+            metricViewName: string;
+            metricViewSha256?: string | null;
+            metricViewYaml?: string | null;
+            outcome: components["schemas"]["DatabricksMetricViewPublicationViewResultOutcome"];
+            source?: string | null;
+        };
+        /** @enum {string} */
+        DatabricksMetricViewPublicationViewResultOutcome: "success" | "failed";
         DbtSyncCancelResponse: {
             message: string;
         };
@@ -3548,6 +3918,8 @@ export interface components {
             gitRef?: string | null;
             lastStage?: string | null;
             phases?: components["schemas"]["DbtSyncRunPhase"][] | null;
+            /** @description Where this sync got its dbt metadata: `git` (Cube cloned the dbt repository and ran dbt) or `manifest` (the caller uploaded a `manifest.json` and no repository was accessed). Runs predating the manifest source report `git`. */
+            source: string;
             /** @description When the sync started, as an ISO 8601 timestamp. See completedAt before comparing the two. */
             startedAt: string;
             stats?: components["schemas"]["DbtSyncRunStats"] | null;
@@ -3575,8 +3947,10 @@ export interface components {
         };
         DbtSyncRunStats: {
             cubeCount?: number | null;
+            dbtVersion?: string | null;
             generatedFileCount?: number | null;
             macros?: number | null;
+            manifestGeneratedAt?: string | null;
             models?: number | null;
             sources?: number | null;
         };
@@ -3800,6 +4174,26 @@ export interface components {
         };
         /** @enum {string} */
         EmbedAccessTenantEntryAction: "read" | "none";
+        EmbedDashboardCommentDto: {
+            body: string;
+            createdAt: string;
+            dashboardId: string;
+            editedAt?: (string) | null;
+            id: number;
+            isOwn: boolean;
+            removedAt?: (string) | null;
+            userId?: number | null;
+        };
+        EmbedDashboardCommentThreadDto: {
+            replies: components["schemas"]["EmbedDashboardCommentDto"][];
+            resolvedAt?: (string) | null;
+            resolvedBy?: number | null;
+            root: components["schemas"]["EmbedDashboardCommentDto"];
+        };
+        EmbedDashboardCommentThreadsListResponse: {
+            items: components["schemas"]["EmbedDashboardCommentThreadDto"][];
+            pageInfo: components["schemas"]["PageInfo"];
+        };
         EmbedGroupMemberInput: {
             embedUserId?: number | null;
             externalId?: string | null;
@@ -3812,19 +4206,41 @@ export interface components {
             addedMembers: components["schemas"]["EmbedUser"][];
             unchangedMembers: components["schemas"]["EmbedUser"][];
         };
+        EmbedMentionableUserDto: {
+            email?: string | null;
+            firstName?: string | null;
+            id: number;
+            username: string;
+        };
+        EmbedMentionableUsersListResponse: {
+            items: components["schemas"]["EmbedMentionableUserDto"][];
+            pageInfo: components["schemas"]["PageInfo"];
+        };
         EmbedPythonFilteredRunInput: {
             reportId: number;
             reportVersionId: number;
             sqlQuery: string;
         };
         EmbedSessionSettings: {
+            allowAi?: boolean | null;
             allowChatWorkspaceAuthoring?: boolean | null;
+            locale?: string | null;
+            showAiWidgets?: boolean | null;
             showDashboardChat?: boolean | null;
+            showDashboardSettings?: boolean | null;
+            showGroupByCube?: boolean | null;
+            showMemberNames?: boolean | null;
+            showWorkbookChat?: boolean | null;
+            showWorkbookShare?: boolean | null;
+            timezone?: string | null;
         };
         EmbedSettings: {
+            allowAi?: boolean | null;
             enableDashboardComments?: boolean | null;
             locale?: string | null;
+            showAiWidgets?: boolean | null;
             showDashboardChat?: boolean | null;
+            showWorkbookChat?: boolean | null;
             timezone?: string | null;
         };
         EmbedTenant: {
@@ -3837,6 +4253,12 @@ export interface components {
         EmbedTenantProfile: {
             displayName?: string | null;
         };
+        /** @enum {string} */
+        EmbedTenantWorkbooksListQueryAccessSource: "tenant" | "allEmbedUsers" | "folder";
+        EmbedTenantWorkbooksListResponse: {
+            items: components["schemas"]["Workbook"][];
+            pageInfo: components["schemas"]["PageInfo"];
+        };
         EmbedTenantsPublicResponse: {
             items: components["schemas"]["EmbedTenant"][];
             pageInfo: components["schemas"]["PageInfo"];
@@ -4603,6 +5025,28 @@ export interface components {
             id: number;
             name: string;
         };
+        SaveDatabricksMetricViewIntegrationInput: {
+            deletionPolicy?: components["schemas"]["SaveDatabricksMetricViewIntegrationInputDeletionPolicy"];
+            enabled: boolean;
+            /** @description Use 0 to create; otherwise pass the configurationVersion returned by GET. */
+            expectedConfigurationVersion: number;
+            selectionMode: components["schemas"]["SaveDatabricksMetricViewIntegrationInputSelectionMode"];
+            sourceOverrides?: {
+                [key: string]: string;
+            };
+            targetCatalog: string;
+            targetNamePrefix?: string;
+            targetNames?: {
+                [key: string]: string;
+            };
+            targetSchema: string;
+            viewNameRegex?: string;
+            viewNames?: string[];
+        };
+        /** @enum {string} */
+        SaveDatabricksMetricViewIntegrationInputDeletionPolicy: "retain" | "delete-managed";
+        /** @enum {string} */
+        SaveDatabricksMetricViewIntegrationInputSelectionMode: "all" | "selected" | "pattern";
         SetBranchStagingEnvironmentRequest: {
             branchId?: number | null;
             branchName?: string | null;
@@ -4611,6 +5055,9 @@ export interface components {
         SetBranchStagingEnvironmentResponse: {
             data: components["schemas"]["BranchResponse"];
         };
+        SetEmbedDashboardCommentResolvedBody: {
+            resolved: boolean;
+        };
         SetEnvVariablesInput: {
             env_variables: components["schemas"]["EnvVariableItem"][];
         };
@@ -4650,8 +5097,14 @@ export interface components {
         StartDashboardExportInputFormat: "png" | "pdf";
         StartDbtSyncInput: {
             branchName?: string | null;
+            manifest?: {
+                [key: string]: any;
+            } | null;
             ref?: string | null;
+            source?: components["schemas"]["StartDbtSyncInputSource"] | null;
         };
+        /** @enum {string} */
+        StartDbtSyncInputSource: "git" | "manifest";
         StartDevModeRequest: {
             branchName?: string | null;
         };
@@ -4740,6 +5193,9 @@ export interface components {
         };
         /** @enum {string} */
         UpdateEmbedAccessInputAction: "read" | "none";
+        UpdateEmbedDashboardCommentBody: {
+            body: string;
+        };
         UpdateEmbedGroupInput: {
             description?: string | null;
         };
@@ -5844,17 +6300,13 @@ export interface operations {
             };
         };
     };
-    "DbtSyncPublicController.listDbtSyncs": {
+    "DatabricksMetricViewIntegrationPublicController.getIntegration": {
         parameters: {
-            query?: {
-                status?: components["schemas"]["DbtSyncRunsQueryStatus"] | null;
-                trigger?: components["schemas"]["DbtSyncRunsQueryTrigger"] | null;
-                after?: string;
-                first?: number;
-            };
+            query?: never;
             header?: never;
             path: {
                 deploymentId: number;
+                dataSourceName: string;
             };
             cookie?: never;
         };
@@ -5865,24 +6317,25 @@ export interface operations {
                     [name: string]: any;
                 };
                 content: {
-                    "application/json": components["schemas"]["DbtSyncRunListResponse"];
+                    "application/json": components["schemas"]["DatabricksMetricViewIntegrationResponse"];
                 };
             };
         };
     };
-    "DbtSyncPublicController.startDbtSync": {
+    "DatabricksMetricViewIntegrationPublicController.saveIntegration": {
         parameters: {
             query?: never;
             header?: never;
             path: {
                 deploymentId: number;
+                dataSourceName: string;
             };
             cookie?: never;
         };
-        /** @description StartDbtSyncInput */
+        /** @description SaveDatabricksMetricViewIntegrationInput */
         requestBody?: {
             content: {
-                "application/json": components["schemas"]["StartDbtSyncInput"];
+                "application/json": components["schemas"]["SaveDatabricksMetricViewIntegrationInput"];
             };
         };
         responses: {
@@ -5891,23 +6344,168 @@ export interface operations {
                     [name: string]: any;
                 };
                 content: {
-                    "application/json": components["schemas"]["DbtSyncResponse"];
+                    "application/json": components["schemas"]["DatabricksMetricViewIntegrationResponse"];
                 };
             };
         };
     };
-    "DbtSyncPublicController.getDbtSyncStatus": {
+    "DatabricksMetricViewPublicationPublicController.startPreview": {
         parameters: {
             query?: never;
             header?: never;
             path: {
                 deploymentId: number;
-                syncJobId: string;
             };
             cookie?: never;
         };
-        requestBody?: never;
-        responses: {
+        /** @description DatabricksMetricViewPublicationPreviewInput */
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DatabricksMetricViewPublicationPreviewInput"];
+            };
+        };
+        responses: {
+            202: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": components["schemas"]["DatabricksMetricViewPublicationPreviewStartResponse"];
+                };
+            };
+        };
+    };
+    "DatabricksMetricViewPublicationPublicController.previewStatus": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                deploymentId: number;
+                previewId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": components["schemas"]["DatabricksMetricViewPublicationPreviewStatusResponse"];
+                };
+            };
+        };
+    };
+    "DatabricksMetricViewPublicationPublicController.cancelPreview": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                deploymentId: number;
+                previewId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful response */
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": any;
+                };
+            };
+        };
+    };
+    "DatabricksMetricViewPublicationPublicController.previewResult": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                deploymentId: number;
+                previewId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": components["schemas"]["DatabricksMetricViewPublicationPreviewResultResponse"];
+                };
+            };
+        };
+    };
+    "DbtSyncPublicController.listDbtSyncs": {
+        parameters: {
+            query?: {
+                status?: components["schemas"]["DbtSyncRunsQueryStatus"] | null;
+                trigger?: components["schemas"]["DbtSyncRunsQueryTrigger"] | null;
+                after?: string;
+                first?: number;
+            };
+            header?: never;
+            path: {
+                deploymentId: number;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": components["schemas"]["DbtSyncRunListResponse"];
+                };
+            };
+        };
+    };
+    "DbtSyncPublicController.startDbtSync": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                deploymentId: number;
+            };
+            cookie?: never;
+        };
+        /** @description StartDbtSyncInput */
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["StartDbtSyncInput"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": components["schemas"]["DbtSyncResponse"];
+                };
+            };
+        };
+    };
+    "DbtSyncPublicController.getDbtSyncStatus": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                deploymentId: number;
+                syncJobId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
             200: {
                 headers: {
                     [name: string]: any;
@@ -5984,6 +6582,32 @@ export interface operations {
             };
         };
     };
+    "DashboardEmbedAccessPublicController.listEmbedTenantWorkbooks": {
+        parameters: {
+            query?: {
+                accessSource?: components["schemas"]["EmbedTenantWorkbooksListQueryAccessSource"] | null;
+                after?: string;
+                first?: number;
+            };
+            header?: never;
+            path: {
+                deploymentId: number;
+                embedTenantName: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": components["schemas"]["EmbedTenantWorkbooksListResponse"];
+                };
+            };
+        };
+    };
     "EnvVariablesPublicController.getEnvVariables": {
         parameters: {
             query?: {
@@ -7739,6 +8363,160 @@ export interface operations {
             };
         };
     };
+    "EmbedPublicController.listDashboardComments": {
+        parameters: {
+            query?: {
+                includeResolved?: boolean | null;
+                resolvedOnly?: boolean | null;
+                after?: string;
+                first?: number;
+            };
+            header?: never;
+            path: {
+                publicId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": components["schemas"]["EmbedDashboardCommentThreadsListResponse"];
+                };
+            };
+        };
+    };
+    "EmbedPublicController.createDashboardComment": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                publicId: string;
+            };
+            cookie?: never;
+        };
+        /** @description CreateEmbedDashboardCommentBody */
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["CreateEmbedDashboardCommentBody"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": components["schemas"]["EmbedDashboardCommentDto"];
+                };
+            };
+        };
+    };
+    "EmbedPublicController.listMentionableEmbedUsers": {
+        parameters: {
+            query?: {
+                search?: string | null;
+                after?: string;
+                first?: number;
+            };
+            header?: never;
+            path: {
+                publicId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": components["schemas"]["EmbedMentionableUsersListResponse"];
+                };
+            };
+        };
+    };
+    "EmbedPublicController.removeDashboardComment": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                publicId: string;
+                commentId: number;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful response */
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": any;
+                };
+            };
+        };
+    };
+    "EmbedPublicController.updateDashboardComment": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                publicId: string;
+                commentId: number;
+            };
+            cookie?: never;
+        };
+        /** @description UpdateEmbedDashboardCommentBody */
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["UpdateEmbedDashboardCommentBody"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": components["schemas"]["EmbedDashboardCommentDto"];
+                };
+            };
+        };
+    };
+    "EmbedPublicController.setDashboardCommentResolved": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                publicId: string;
+                commentId: number;
+            };
+            cookie?: never;
+        };
+        /** @description SetEmbedDashboardCommentResolvedBody */
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["SetEmbedDashboardCommentResolvedBody"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: any;
+                };
+                content: {
+                    "application/json": components["schemas"]["EmbedDashboardCommentThreadDto"];
+                };
+            };
+        };
+    };
     "EmbedPublicController.postDashboardPythonRun": {
         parameters: {
             query?: never;