@datalayer/core 1.0.20 → 1.0.22

package/lib/state/substates/IAMState.js

@@ -179,13 +179,6 @@ export const iamStore = createStore((set, get) => {
                 storeUser(user);
                 storeToken(token);
                 set(() => ({ user, token }));
-                // TODO Centralize User Setting Management.
-                const aiagentsRunUrl = user.settings?.aiAgentsUrl;
-                if (aiagentsRunUrl) {
-                    coreStore.getState().setConfiguration({
-                        aiagentsRunUrl,
-                    });
-                }
             }
             catch (error) {
                 if (error.name === 'RunResponseError' &&

package/lib/state/substates/RuntimesState.d.ts

@@ -1,6 +1,6 @@
 import type { IMultiServiceManager } from '../../stateful/runtimes';
 import type { IRuntimesConfiguration } from '../../config';
-import type { IRuntimePod, IRuntimeSnapshot, IRuntimeModel } from '../../models';
+import type { IRuntimePod, ICodeSandboxSnapshot, IRuntimeModel } from '../../models';
 /**
  * Datalayer Runtimes state.
  */
@@ -49,21 +49,21 @@ export type RuntimesState = {
     showDisclaimer: boolean;
     setShowDisclaimer: (showDisclaimer: boolean) => void;
     /**
-     * Runtime snapshots.
+     * Code Sandbox snapshots.
      */
-    runtimeSnapshots: readonly IRuntimeSnapshot[];
+    runtimeSnapshots: readonly ICodeSandboxSnapshot[];
     /**
-     * Add a runtime snapshot.
+     * Add a code sandbox snapshot.
      */
-    addRuntimeSnapshot: (snapshot: IRuntimeSnapshot) => void;
+    addSandboxSnapshot: (snapshot: ICodeSandboxSnapshot) => void;
     /**
-     * Remove a Runtime Snapshot.
+     * Remove a Code Sandbox Snapshot.
      */
-    removeRuntimeSnapshot: (id: string) => void;
+    removeSandboxSnapshot: (id: string) => void;
     /**
-     * Set Runtime Snapshots.
+     * Set Code Sandbox Snapshots.
      */
-    setRuntimeSnapshots: (snapshots: IRuntimeSnapshot[]) => void;
+    setSandboxSnapshots: (snapshots: ICodeSandboxSnapshot[]) => void;
     /**
      * Package version.
      */

package/lib/state/substates/RuntimesState.js

@@ -90,7 +90,7 @@ export const runtimesStore = createStore((set, get) => {
         /**
          * Add a Kernel Snapshot
          */
-        addRuntimeSnapshot: (snapshot) => {
+        addSandboxSnapshot: (snapshot) => {
             const snapshots = get().runtimeSnapshots;
             const index = snapshots.findIndex(s => s.id === snapshot.id);
             if (index < 0) {
@@ -106,7 +106,7 @@ export const runtimesStore = createStore((set, get) => {
         /**
          * Remove a Kernel Snapshot.
          */
-        removeRuntimeSnapshot: (id) => {
+        removeSandboxSnapshot: (id) => {
             const snapshots = get().runtimeSnapshots;
             const index = snapshots.findIndex(s => s.id === id);
             if (index >= 0) {
@@ -118,7 +118,7 @@ export const runtimesStore = createStore((set, get) => {
         /**
          * Set Kernel Snapshots.
          */
-        setRuntimeSnapshots: (snapshots) => {
+        setSandboxSnapshots: (snapshots) => {
             if (!JSONExt.deepEqual(get().runtimeSnapshots, snapshots)) {
                 set({ runtimeSnapshots: [...snapshots] });
             }

package/lib/stateful/runtimes/actions.d.ts

@@ -1,5 +1,5 @@
 import { IRuntimeOptions } from '../../api';
-import type { IRuntimeSnapshot, IDatalayerEnvironment, IRuntimePod } from '../../models';
+import type { ICodeSandboxSnapshot, IDatalayerEnvironment, IRuntimePod } from '../../models';
 /**
  * Get available Environments.
  */
@@ -45,15 +45,15 @@ export declare function snapshotRuntime(options: {
      * Whether to stop the runtime after the snapshot completion or not.
      */
     stop?: boolean;
-}): Promise<IRuntimeSnapshot>;
+}): Promise<ICodeSandboxSnapshot | undefined>;
 /**
- * Get Runtime Snapshots.
+ * Get Code Sandbox Snapshots.
  */
-export declare function getRuntimeSnapshots(): Promise<IRuntimeSnapshot[]>;
+export declare function getSandboxSnapshots(): Promise<ICodeSandboxSnapshot[]>;
 /**
- * Load a Runtime Snapshot within a Runtime.
+ * Load a Code Sandbox Snapshot within a Runtime.
  */
-export declare function loadRuntimeSnapshot(options: {
+export declare function loadSandboxSnapshot(options: {
     /**
      * Runtime ID
      */
@@ -64,35 +64,35 @@ export declare function loadRuntimeSnapshot(options: {
     from: string;
 }): Promise<void>;
 /**
- * Returns the Runtime Snapshot download URL.
+ * Returns the Code Sandbox Snapshot download URL.
  *
  * @param id Snapshot UID to download
  * @returns The download URL
  */
-export declare function createRuntimeSnapshotDownloadURL(id: string): string;
+export declare function createSandboxSnapshotDownloadURL(id: string): string;
 /**
- * Export a Runtime Snapshot.
+ * Export a Code Sandbox Snapshot.
  *
- * @param id Runtime snapshot UID to download
+ * @param id Code Sandbox snapshot UID to download
  */
-export declare function exportRuntimeSnapshot(id: string): void;
+export declare function exportCodeSandboxSnapshot(id: string): void;
 /**
- * Delete a Runtime Snapshot.
+ * Delete a Code Sandbox Snapshot.
  */
-export declare function deleteRuntimeSnapshot(id: string): Promise<void>;
+export declare function deleteCodeSandboxSnapshot(id: string): Promise<void>;
 /**
- * Update Runtime Snapshot metadata.
+ * Update Code Sandbox Snapshot metadata.
  */
-export declare function updateRuntimeSnapshot(id: string, metadata: {
+export declare function updateCodeSandboxSnapshot(id: string, metadata: {
     name?: string;
     description?: string;
 }): Promise<void>;
 /**
- * Upload a Runtime Snapshot.
+ * Upload a Code Sandbox Snapshot.
  *
  * Note: The promise will be rejected if the runtime state is empty.
  */
-export declare function uploadRuntimeSnapshot(options: {
+export declare function uploadCodeSandboxSnapshot(options: {
     file: File | Blob;
     metadata: {
         filename: string;

package/lib/stateful/runtimes/actions.js

@@ -9,9 +9,8 @@ import { URLExt } from '@jupyterlab/coreutils';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { Upload } from 'tus-js-client';
 import { requestDatalayerAPI, } from '../../api/index.js';
-import { asRuntimeSnapshot } from '../../models/index.js';
+import { asCodeSandboxSnapshot } from '../../models/index.js';
 import { iamStore, runtimesStore } from '../../state/index.js';
-import { sleep } from '../../utils/index.js';
 /**
  * Get available Environments.
  */
@@ -100,7 +99,7 @@ export async function deleteRuntime(options) {
  */
 export async function snapshotRuntime(options) {
     const data = await requestDatalayerAPI({
-        url: URLExt.join(runtimesStore.getState().runtimesRunUrl, 'api/runtimes/v1/runtime-snapshots'),
+        url: URLExt.join(runtimesStore.getState().runtimesRunUrl, 'api/runtimes/v1/sandbox-snapshots'),
         method: 'POST',
         body: {
             pod_name: options.id,
@@ -110,29 +109,34 @@ export async function snapshotRuntime(options) {
         },
         token: iamStore.getState().token,
     });
-    if (!data.success || !data.snapshot) {
-        throw new Error(`Failed to take the runtime snapshot ${options.id} - ${data}`);
+    if (!data.success) {
+        throw new Error(`Failed to take the code sandbox snapshot ${options.id} - ${data}`);
+    }
+    // Runtimes service can return 202 Accepted without inline snapshot payload
+    // while the snapshot lifecycle completes asynchronously via pub-sub events.
+    if (!data.snapshot) {
+        return undefined;
     }
-    return asRuntimeSnapshot(data.snapshot);
+    return asCodeSandboxSnapshot(data.snapshot);
 }
 /**
- * Get Runtime Snapshots.
+ * Get Code Sandbox Snapshots.
  */
-export async function getRuntimeSnapshots() {
+export async function getSandboxSnapshots() {
     const data = await requestDatalayerAPI({
-        url: URLExt.join(runtimesStore.getState().runtimesRunUrl, 'api/runtimes/v1/runtime-snapshots'),
+        url: URLExt.join(runtimesStore.getState().runtimesRunUrl, 'api/runtimes/v1/sandbox-snapshots'),
         token: iamStore.getState().token,
     });
     if (!data.success) {
-        console.error('Failed to fetch runtime snapshots.', data);
+        console.error('Failed to fetch code sandbox snapshots.', data);
         return [];
     }
-    return (data.snapshots ?? []).map(asRuntimeSnapshot);
+    return (data.snapshots ?? []).map(asCodeSandboxSnapshot);
 }
 /**
- * Load a Runtime Snapshot within a Runtime.
+ * Load a Code Sandbox Snapshot within a Runtime.
  */
-export async function loadRuntimeSnapshot(options) {
+export async function loadSandboxSnapshot(options) {
     const data = await requestDatalayerAPI({
         url: URLExt.join(runtimesStore.getState().runtimesRunUrl, 'api/runtimes/v1/runtimes', options.id),
         method: 'PUT',
@@ -142,29 +146,29 @@ export async function loadRuntimeSnapshot(options) {
         token: iamStore.getState().token,
     });
     if (!data.success) {
-        throw new Error(`Failed to load the runtime snapshot; ${data.message}`);
+        throw new Error(`Failed to load the code sandbox snapshot; ${data.message}`);
     }
 }
 /**
- * Returns the Runtime Snapshot download URL.
+ * Returns the Code Sandbox Snapshot download URL.
  *
  * @param id Snapshot UID to download
  * @returns The download URL
  */
-export function createRuntimeSnapshotDownloadURL(id) {
-    return (URLExt.join(runtimesStore.getState().runtimesRunUrl, `api/runtimes/v1/runtime-snapshots/${id}`) +
+export function createSandboxSnapshotDownloadURL(id) {
+    return (URLExt.join(runtimesStore.getState().runtimesRunUrl, `api/runtimes/v1/sandbox-snapshots/${id}`) +
         URLExt.objectToQueryString({
             download: '1',
             token: iamStore.getState().token ?? '',
         }));
 }
 /**
- * Export a Runtime Snapshot.
+ * Export a Code Sandbox Snapshot.
  *
- * @param id Runtime snapshot UID to download
+ * @param id Code Sandbox snapshot UID to download
  */
-export function exportRuntimeSnapshot(id) {
-    const url = createRuntimeSnapshotDownloadURL(id);
+export function exportCodeSandboxSnapshot(id) {
+    const url = createSandboxSnapshotDownloadURL(id);
     const element = document.createElement('a');
     element.href = url;
     element.download = '';
@@ -173,46 +177,22 @@ export function exportRuntimeSnapshot(id) {
     document.body.removeChild(element);
 }
 /**
- * Delete a Runtime Snapshot.
+ * Delete a Code Sandbox Snapshot.
  */
-export async function deleteRuntimeSnapshot(id) {
+export async function deleteCodeSandboxSnapshot(id) {
     await requestDatalayerAPI({
-        url: URLExt.join(runtimesStore.getState().runtimesRunUrl, `api/runtimes/v1/runtime-snapshots/${id}`),
+        url: URLExt.join(runtimesStore.getState().runtimesRunUrl, `api/runtimes/v1/sandbox-snapshots/${id}`),
         method: 'DELETE',
         token: iamStore.getState().token,
     });
-    // Poll Runtime Snapshot state up-to its deletion.
-    try {
-        let sleepTimeout = 1000;
-        while (true) {
-            await sleep(sleepTimeout);
-            sleepTimeout *= 2;
-            const response = await requestDatalayerAPI({
-                url: URLExt.join(runtimesStore.getState().runtimesRunUrl, `api/runtimes/v1/runtime-snapshots/${id}`),
-                token: iamStore.getState().token,
-            });
-            if (response.success === false) {
-                throw new Error(response.message);
-            }
-        }
-    }
-    catch (error) {
-        if (error.name === 'RunResponseError' &&
-            error.response.status === 404) {
-            // Expected not found
-        }
-        else {
-            throw error;
-        }
-    }
 }
 /**
- * Update Runtime Snapshot metadata.
+ * Update Code Sandbox Snapshot metadata.
  */
-export async function updateRuntimeSnapshot(id, metadata) {
+export async function updateCodeSandboxSnapshot(id, metadata) {
     if (metadata.name || metadata.description) {
         await requestDatalayerAPI({
-            url: URLExt.join(runtimesStore.getState().runtimesRunUrl, `api/runtimes/v1/runtime-snapshots/${id}`),
+            url: URLExt.join(runtimesStore.getState().runtimesRunUrl, `api/runtimes/v1/sandbox-snapshots/${id}`),
             method: 'PATCH',
             body: { ...metadata },
             token: iamStore.getState().token,
@@ -220,19 +200,19 @@ export async function updateRuntimeSnapshot(id, metadata) {
     }
 }
 /**
- * Upload a Runtime Snapshot.
+ * Upload a Code Sandbox Snapshot.
  *
  * Note: The promise will be rejected if the runtime state is empty.
  */
-export async function uploadRuntimeSnapshot(options) {
+export async function uploadCodeSandboxSnapshot(options) {
     if (options.file.size === 0) {
-        return Promise.reject('Empty Runtime Snapshot.');
+        return Promise.reject('Empty Code Sandbox Snapshot.');
     }
     const tracker = new PromiseDelegate();
     // Create a new tus upload.
     const upload = new Upload(options.file, {
         // Endpoint is the upload creation URL from your tus server.
-        endpoint: `${runtimesStore.getState().runtimesRunUrl}/api/runtimes/v1/runtime-snapshots/upload`,
+        endpoint: `${runtimesStore.getState().runtimesRunUrl}/api/runtimes/v1/sandbox-snapshots/upload`,
         headers: { Authorization: `Bearer ${iamStore.getState().token}` },
         // Retry delays will enable tus-js-client to automatically retry on errors.
         // retryDelays: [0, 3000, 5000, 10000, 20000],

package/lib/stateful/runtimes/apis.d.ts

@@ -5,7 +5,7 @@ import { ISessionContext } from '@jupyterlab/apputils';
 import { ServiceManager, Kernel, ServerConnection } from '@jupyterlab/services';
 import { IDisposable } from '@lumino/disposable';
 import { ISignal } from '@lumino/signaling';
-import type { IRuntimeSnapshot, IRuntimeCapabilities, IRuntimeModel, IDatalayerEnvironment, IRuntimeType, IRuntimeLocation } from '../../models';
+import type { ICodeSandboxSnapshot, IRuntimeCapabilities, IRuntimeModel, IDatalayerEnvironment, IRuntimeType, IRuntimeLocation } from '../../models';
 /**
  * Abstract interface for the Datalayer session context.
  * It extends the JupyterLab session context
@@ -188,13 +188,13 @@ export interface IRemoteRuntimesManager extends IDisposable {
          * Whether to stop the kernel after the snapshot completion or not.
          */
         stop?: boolean;
-    }): Promise<IRuntimeSnapshot | undefined>;
+    }): Promise<ICodeSandboxSnapshot | undefined>;
     /**
      * Load a snapshot within a runtim
      *
      * The runtime may be given by its `id` or `podName`.
      */
-    loadRuntimeSnapshot(options: {
+    loadSandboxSnapshot(options: {
         /**
          * The kernel id
          */

package/lib/stateful/runtimes/snapshots.d.ts

@@ -12,13 +12,13 @@ type Props = {
  *
  * Note: You should use this only for browser runtimes.
  */
-export declare function createRuntimeSnapshot(props: Props): Promise<void>;
+export declare function createSandboxSnapshot(props: Props): Promise<void>;
 /**
  * Load a snapshot within a browser kernel.
  *
  * Note: You should use this only for browser kernels.
  */
-export declare function loadBrowserRuntimeSnapshot({ connection, id, }: {
+export declare function loadBrowserSandboxSnapshot({ connection, id, }: {
     connection: Kernel.IKernelConnection;
     id: string;
 }): Promise<void>;

package/lib/stateful/runtimes/snapshots.js

@@ -3,13 +3,13 @@
  * Distributed under the terms of the Modified BSD License.
  */
 import { KernelExecutor } from '@datalayer/jupyter-react';
-import { createRuntimeSnapshotDownloadURL, uploadRuntimeSnapshot } from './index.js';
+import { createSandboxSnapshotDownloadURL, uploadCodeSandboxSnapshot } from './index.js';
 /**
  * Snapshot a runtime through the frontend and upload it to the cloud.
  *
  * Note: You should use this only for browser runtimes.
  */
-export async function createRuntimeSnapshot(props) {
+export async function createSandboxSnapshot(props) {
     const { connection, metadata, onUploadProgress } = props;
     const dump = await new KernelExecutor({ connection }).execute(GET_RUNTIME_SNAPSHOT_SNIPPET, {
         storeHistory: false,
@@ -19,7 +19,7 @@ export async function createRuntimeSnapshot(props) {
     // Convert the data to blob.
     const bytes = base64ToBytes(serializedData);
     const file = new Blob([bytes.buffer]);
-    return uploadRuntimeSnapshot({
+    return uploadCodeSandboxSnapshot({
         file,
         metadata,
         onProgress: onUploadProgress,
@@ -36,14 +36,14 @@ function base64ToBytes(base64) {
  *
  * Note: You should use this only for browser kernels.
  */
-export async function loadBrowserRuntimeSnapshot({ connection, id, }) {
-    const downloadURL = createRuntimeSnapshotDownloadURL(id);
+export async function loadBrowserSandboxSnapshot({ connection, id, }) {
+    const downloadURL = createSandboxSnapshotDownloadURL(id);
     const response = await fetch(downloadURL);
     const buffer = await response.arrayBuffer();
     const base64 = bytesToBase64(new Uint8Array(buffer));
     await new KernelExecutor({
         connection,
-    }).execute(getLoadRuntimeSnapshotSnippet(base64), {
+    }).execute(getLoadSandboxSnapshotSnippet(base64), {
         storeHistory: false,
         silent: true,
     });
@@ -104,7 +104,7 @@ const GET_RUNTIME_SNAPSHOT_SNIPPET = `def _create_snapshot():
 _create_snapshot()
 del _create_snapshot
 `;
-function getLoadRuntimeSnapshotSnippet(content) {
+function getLoadSandboxSnapshotSnippet(content) {
     return `async def _load_snapshot():
     import os
     import logging

package/lib/utils/Format.d.ts

@@ -9,6 +9,12 @@ export declare const MEMORY_UNIT_LIMITS: {
     readonly [U in MemoryUnit]: number;
 };
 export declare function formatForDisplay(numBytes: number | undefined, units?: MemoryUnit | undefined): string;
+/**
+ * Format a byte size value using a human-friendly unit.
+ *
+ * Examples: 0 B, 532 B, 1.2 KB, 24 MB, 1.45 GB
+ */
+export declare function formatByteSize(numBytes: number | string | null | undefined): string;
 /**
  * Given a number of bytes, convert to the most human-readable
  * format, (GB, TB, etc).

package/lib/utils/Format.js

@@ -17,6 +17,23 @@ export function formatForDisplay(numBytes, units) {
     const lu = convertToLargestUnit(numBytes, units);
     return lu[0].toFixed(2) + ' ' + lu[1];
 }
+/**
+ * Format a byte size value using a human-friendly unit.
+ *
+ * Examples: 0 B, 532 B, 1.2 KB, 24 MB, 1.45 GB
+ */
+export function formatByteSize(numBytes) {
+    const normalizedNumBytes = typeof numBytes === 'string' ? Number(numBytes) : numBytes;
+    if (!Number.isFinite(normalizedNumBytes) || !normalizedNumBytes || normalizedNumBytes < 0) {
+        return '0 B';
+    }
+    const [value, unit] = convertToLargestUnit(normalizedNumBytes);
+    const decimals = value >= 100 ? 0 : value >= 10 ? 1 : 2;
+    const formattedValue = value
+        .toFixed(decimals)
+        .replace(/\.0+$|(\.[0-9]*[1-9])0+$/, '$1');
+    return `${formattedValue} ${unit}`;
+}
 /**
  * Given a number of bytes, convert to the most human-readable
  * format, (GB, TB, etc).

package/lib/utils/Handles.d.ts

@@ -0,0 +1,3 @@
+export declare function isExternalUrnHandle(handle?: string): boolean;
+export declare function formatFriendlyHandle(handle?: string): string;
+export declare function normalizeHandleFromName(value?: string): string;

package/lib/utils/Handles.js

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+const EXT_URN_PREFIX = 'urn:dla:iam:ext::';
+export function isExternalUrnHandle(handle) {
+    const normalized = (handle || '').trim().toLowerCase();
+    return normalized.startsWith(EXT_URN_PREFIX);
+}
+export function formatFriendlyHandle(handle) {
+    const normalizedHandle = (handle || '').trim();
+    if (!normalizedHandle) {
+        return 'unknown';
+    }
+    if (!isExternalUrnHandle(normalizedHandle)) {
+        return normalizedHandle;
+    }
+    const externalId = normalizedHandle.slice(EXT_URN_PREFIX.length);
+    const [providerRaw, ...restParts] = externalId.split(':');
+    const provider = (providerRaw || '').toLowerCase();
+    const providerLabel = provider === 'github'
+        ? 'GitHub'
+        : provider === 'google'
+            ? 'Google'
+            : providerRaw || 'External';
+    const identifier = restParts.join(':').trim();
+    if (!identifier) {
+        return providerLabel;
+    }
+    const shortIdentifier = identifier.length > 18 ? `${identifier.slice(0, 15)}...` : identifier;
+    return `${providerLabel} ${shortIdentifier}`;
+}
+export function normalizeHandleFromName(value) {
+    const source = String(value || '').trim();
+    if (!source) {
+        return '';
+    }
+    const transliterated = source
+        .replace(/ß/g, 'ss')
+        .replace(/æ/gi, 'ae')
+        .replace(/œ/gi, 'oe')
+        .replace(/ø/gi, 'o')
+        .replace(/đ/gi, 'd')
+        .replace(/þ/gi, 'th')
+        .replace(/ł/gi, 'l')
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '');
+    return transliterated
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-{2,}/g, '-');
+}

package/lib/utils/Snapshot.d.ts

@@ -4,4 +4,4 @@
  * @param suffix Name prefix
  * @returns The kernel snapshot name
  */
-export declare function createRuntimeSnapshotName(suffix: string): string;
+export declare function createSandboxSnapshotName(suffix: string): string;

package/lib/utils/Snapshot.js

@@ -16,6 +16,6 @@ const KERNEL_SNAPSHOT_DESCRIPTION_CONFIGURATION = {
  * @param suffix Name prefix
  * @returns The kernel snapshot name
  */
-export function createRuntimeSnapshotName(suffix) {
+export function createSandboxSnapshotName(suffix) {
     return `${uniqueNamesGenerator(KERNEL_SNAPSHOT_DESCRIPTION_CONFIGURATION)}-${suffix}`;
 }

package/lib/utils/index.d.ts

@@ -10,6 +10,7 @@ export * from './DownloadFile';
 export * from './Env';
 export * from './File';
 export * from './Format';
+export * from './Handles';
 export * from './Ids';
 export * from './Jwt';
 export * from './Jupyter';

package/lib/utils/index.js

@@ -14,6 +14,7 @@ export * from './DownloadFile.js';
 export * from './Env.js';
 export * from './File.js';
 export * from './Format.js';
+export * from './Handles.js';
 export * from './Ids.js';
 export * from './Jwt.js';
 export * from './Jupyter.js';

package/lib/views/datasources/DatasourceDetail.d.ts

@@ -1,2 +1,8 @@
-export declare const DatasourceDetail: () => import("react/jsx-runtime").JSX.Element;
+export type DatasourceDetailProps = {
+    /** Optional principal uid used to scope datasource reads/updates. */
+    principalUid?: string;
+    /** Optional principal kind used to scope datasource reads/updates. */
+    principalKind?: 'user' | 'organization' | 'team';
+};
+export declare const DatasourceDetail: ({ principalUid, principalKind, }?: DatasourceDetailProps) => import("react/jsx-runtime").JSX.Element;
 export default DatasourceDetail;