@datalayer/core 1.1.60 → 1.2.10

package/lib/hooks/useContainsFocus.d.ts

@@ -6,4 +6,4 @@ import { type RefObject } from 'react';
  * @type T The type of the container element.
  * @returns The ref to be applied to the container element.
  */
-export declare const useContainsFocus: <T extends HTMLElement>(containerRef?: RefObject<T>, onFocusChange?: (isFocussed: boolean) => void) => void;
+export declare const useContainsFocus: <T extends HTMLElement>(containerRef?: RefObject<T | null>, onFocusChange?: (isFocussed: boolean) => void) => void;

package/lib/hooks/useContents.d.ts

@@ -0,0 +1,334 @@
+import { type BridgeList, type BridgeSession, type DownloadedObject, type AttachmentCreate, type AttachmentList, type ContentAttachment, type ContentAttachmentManifest, type DatasetRevision, type DatasetRevisionCreate, type DatasetRevisionList, type DataServerAttachment, type DatasetClone, type DatasetPublication, type DatasetPublicationCreate, type DatasetPublicationList, type ConditionalCatalogSource, type ContentObject, type ContentSource, type ContentSourceCreate, type ContentSourceUpdate, type Sharing, type ObjectList, type OperationView, type TransferView, type TransferList, type UploadProgress, type VersionList, type HomeFolderQuota, type SourceList, type McpApproval, type McpApprovalList, type McpApprovalStatus, type McpCall, type McpCallCreate, type McpCallList, type McpHealth, type McpSession, type McpSessionCreate, type McpSessionList, type McpToolManifest, type DatasourceCapabilities, type DatasourceQuery, type DatasourceQueryCreate, type DatasourceQueryList, type DatasourceQueryResultBytes, type DatasourceSchema, type DatasourceTest } from '../api/contents';
+import type { CapabilityTicket, CapabilityTicketRequest, DataServerConnectivity, DataServerStatus, IssuedIdentity, CloudObjectList, ConnectionTest, CredentialDiagnostics, ContentsCapabilities, SyncConflictList, SyncSessionList, SyncSessionView, RuntimeMounts } from '../api/contents';
+export type ContentSourceKind = ContentSource['kind'];
+export declare const useDatasetRevisions: (sourceUid?: string) => import("@tanstack/react-query").UseQueryResult<DatasetRevisionList, Error>;
+export declare const useDatasetRevision: (sourceUid?: string, revisionUid?: string) => import("@tanstack/react-query").UseQueryResult<DatasetRevision, Error>;
+export declare const useCreateDatasetRevision: () => import("@tanstack/react-query").UseMutationResult<DatasetRevision, Error, {
+    sourceUid: string;
+    request: DatasetRevisionCreate;
+    idempotencyKey: string;
+}, unknown>;
+export declare const useDatasetPublications: (sourceUid?: string) => import("@tanstack/react-query").UseQueryResult<DatasetPublicationList, Error>;
+export declare const useCreateDatasetPublication: () => import("@tanstack/react-query").UseMutationResult<DatasetPublication, Error, {
+    sourceUid: string;
+    request: DatasetPublicationCreate;
+    idempotencyKey: string;
+}, unknown>;
+/**
+ * Clone a published Dataset into the caller's own catalog.
+ *
+ * The idempotency key is derived from the publication rather than random: a
+ * retried click finds the clone it already made instead of making a second
+ * one.
+ */
+export declare const useCloneDatasetPublication: () => import("@tanstack/react-query").UseMutationResult<DatasetClone, Error, {
+    sourceUid: string;
+    publicationUid: string;
+}, unknown>;
+/**
+ * Attach a published Data Server as a Datasource of the caller's own.
+ *
+ * The idempotency key is derived from the publication: a retried click finds
+ * the Datasource it already made rather than making a second one.
+ */
+export declare const useAttachDataServerPublication: () => import("@tanstack/react-query").UseMutationResult<DataServerAttachment, Error, {
+    sourceUid: string;
+    publicationUid: string;
+}, unknown>;
+export declare const useUnpublishDataset: () => import("@tanstack/react-query").UseMutationResult<DatasetPublication, Error, {
+    sourceUid: string;
+    publicationUid: string;
+}, unknown>;
+export type ContentAttachmentFilters = {
+    sandboxUid?: string;
+    sourceUid?: string;
+    active?: boolean;
+};
+export declare const useContentAttachments: (filters?: ContentAttachmentFilters) => import("@tanstack/react-query").UseQueryResult<AttachmentList, Error>;
+export declare const useContentAttachmentManifest: (sandboxUid?: string) => import("@tanstack/react-query").UseQueryResult<ContentAttachmentManifest, Error>;
+export declare const useCreateContentAttachment: () => import("@tanstack/react-query").UseMutationResult<ContentAttachment, Error, {
+    request: AttachmentCreate;
+    idempotencyKey: string;
+}, unknown>;
+export declare const useRevokeContentAttachment: () => import("@tanstack/react-query").UseMutationResult<ContentAttachment, Error, string, unknown>;
+export type ContentSourceListFilters = {
+    kind?: ContentSourceKind;
+    spaceUid?: string;
+    cursor?: string;
+    limit?: number;
+};
+/** Query the contents visible to the current user. */
+export declare const useContentSources: (filters?: ContentSourceListFilters) => import("@tanstack/react-query").UseQueryResult<SourceList, Error>;
+/**
+ * What this deployment offers and what this caller may do with it.
+ *
+ * The Contents page shows entry points and a create menu; neither can be
+ * decided in the client, which knows neither what is running here nor what
+ * this principal is entitled to. Cached longer than a listing because it
+ * changes when the deployment does, not when a source does.
+ */
+export declare const useContentsCapabilities: () => import("@tanstack/react-query").UseQueryResult<ContentsCapabilities, Error>;
+/** Query one catalog source, including its ETag and effective permissions. */
+export declare const useContentSource: (sourceUid?: string) => import("@tanstack/react-query").UseQueryResult<ConditionalCatalogSource, Error>;
+export declare const useCreateContentSource: () => import("@tanstack/react-query").UseMutationResult<ConditionalCatalogSource, Error, {
+    source: ContentSourceCreate;
+    idempotencyKey: string;
+}, unknown>;
+export declare const useUpdateContentSource: () => import("@tanstack/react-query").UseMutationResult<ConditionalCatalogSource, Error, {
+    sourceUid: string;
+    update: ContentSourceUpdate;
+    etag: string;
+}, unknown>;
+export declare const useArchiveContentSource: () => import("@tanstack/react-query").UseMutationResult<ConditionalCatalogSource, Error, {
+    sourceUid: string;
+    etag: string;
+}, unknown>;
+export declare const useContentSourceSharing: (sourceUid?: string) => import("@tanstack/react-query").UseQueryResult<Sharing, Error>;
+export declare const useReplaceContentSourceSharing: () => import("@tanstack/react-query").UseMutationResult<ConditionalCatalogSource, Error, {
+    sourceUid: string;
+    sharing: Sharing;
+    etag: string;
+}, unknown>;
+/** Resolve and, on first access, provision the authenticated user's folder. */
+export declare const useHomeFolder: () => import("@tanstack/react-query").UseQueryResult<ConditionalCatalogSource, Error>;
+/** Query durable used, reserved and configured Home Folder capacity. */
+export declare const useHomeFolderQuota: () => import("@tanstack/react-query").UseQueryResult<HomeFolderQuota, Error>;
+export type HomeFolderObjectListFilters = {
+    prefix?: string;
+    cursor?: string;
+    limit?: number;
+    order?: 'path' | 'updated';
+};
+/** Browse the authenticated user's persistent folder. */
+export declare const useHomeFolderObjects: (filters?: HomeFolderObjectListFilters) => import("@tanstack/react-query").UseQueryResult<ObjectList, Error>;
+/** Resolve one Home Folder path to its current object metadata. */
+export declare const useHomeFolderObject: (path?: string) => import("@tanstack/react-query").UseQueryResult<ContentObject, Error>;
+/** List immutable versions for a Home Folder object. */
+export declare const useHomeFolderObjectVersions: (objectUid?: string, options?: {
+    cursor?: string;
+    limit?: number;
+}) => import("@tanstack/react-query").UseQueryResult<VersionList, Error>;
+type ObjectMutation = {
+    objectUid: string;
+    idempotencyKey: string;
+};
+/** Soft-delete a Home Folder object and invalidate its browse metadata. */
+export declare const useDeleteHomeFolderObject: () => import("@tanstack/react-query").UseMutationResult<ContentObject, Error, ObjectMutation, unknown>;
+/** Restore an immutable version as the object's new current version. */
+export declare const useRestoreHomeFolderObject: () => import("@tanstack/react-query").UseMutationResult<ContentObject, Error, ObjectMutation & {
+    versionUid: string;
+}, unknown>;
+/** Query an operation, polling only while it can still change. */
+export declare const useContentOperation: (operationUid?: string) => import("@tanstack/react-query").UseQueryResult<OperationView, Error>;
+/** Request cancellation and refresh the shared operation cache. */
+export declare const useCancelContentOperation: () => import("@tanstack/react-query").UseMutationResult<OperationView, Error, string, unknown>;
+/** Poll a resumable transfer so progress survives navigation and reconnects. */
+export declare const useContentTransfer: (transferUid?: string) => import("@tanstack/react-query").UseQueryResult<TransferView, Error>;
+/** List the authenticated user's recent or active durable transfers. */
+export declare const useContentTransfers: (filters?: {
+    active?: boolean;
+    cursor?: string;
+    limit?: number;
+}) => import("@tanstack/react-query").UseQueryResult<TransferList, Error>;
+/** Cancel a transfer and refresh its durable progress plus folder listing. */
+export declare const useCancelContentTransfer: () => import("@tanstack/react-query").UseMutationResult<TransferView, Error, string, unknown>;
+/** The authenticated user's synchronization sessions, active ones polled. */
+export declare const useSyncSessions: (filters?: {
+    active?: boolean;
+    cursor?: string;
+    limit?: number;
+}) => import("@tanstack/react-query").UseQueryResult<SyncSessionList, Error>;
+/** One session, polled while it is still doing something. */
+export declare const useSyncSession: (sessionUid?: string) => import("@tanstack/react-query").UseQueryResult<SyncSessionView, Error>;
+/** The paths a session left for a person to decide. */
+export declare const useSyncConflicts: (sessionUid?: string, openOnly?: boolean) => import("@tanstack/react-query").UseQueryResult<SyncConflictList, Error>;
+/** Decide a conflict; the client applies the decision on its next pass. */
+export declare const useResolveSyncConflict: () => import("@tanstack/react-query").UseMutationResult<SyncSessionView, Error, {
+    sessionUid: string;
+    conflictUid: string;
+    use: "local" | "remote" | "keep-both";
+}, unknown>;
+/** End a session from the page; the client finds out on its next call. */
+export declare const useCancelSyncSession: () => import("@tanstack/react-query").UseMutationResult<SyncSessionView, Error, string, unknown>;
+/**
+ * The bridge of one `local-bridge` attachment, polled while it can still
+ * change; `null` when none has been opened for it yet.
+ */
+export declare const useBridgeSession: (attachmentUid?: string) => import("@tanstack/react-query").UseQueryResult<BridgeSession | null, Error>;
+/** The caller's bridge sessions; the active ones polled. */
+export declare const useBridges: (filters?: {
+    active?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<BridgeList, Error>;
+/** One session by uid, polled until it has ended. */
+export declare const useBridge: (bridgeUid?: string) => import("@tanstack/react-query").UseQueryResult<BridgeSession, Error>;
+/**
+ * Revoke a bridge by uid. The attachment goes `revoking` with it on the
+ * service, so every attachment view refreshes as well as the bridge ones.
+ */
+export declare const useRevokeBridge: () => import("@tanstack/react-query").UseMutationResult<BridgeSession, Error, string, unknown>;
+/** Upload a browser file with resumable verified parts and durable progress. */
+export declare const useUploadHomeFolderFile: () => import("@tanstack/react-query").UseMutationResult<TransferView, Error, {
+    path: string;
+    content: Blob | Uint8Array | ArrayBuffer;
+    idempotencyKey: string;
+    mediaType?: string;
+    overwrite?: "reject" | "replace" | "new-version";
+    onProgress?: (progress: UploadProgress) => void;
+}, unknown>;
+/** Fetch a complete object version or a resumable HTTP byte range. */
+export declare const useDownloadHomeFolderObject: () => import("@tanstack/react-query").UseMutationResult<DownloadedObject, Error, {
+    objectUid: string;
+    versionUid?: string;
+    range?: string;
+}, unknown>;
+/** One page of a Cloud Storage source under a prefix. */
+export declare const useCloudObjects: (sourceUid?: string, options?: {
+    prefix?: string;
+    cursor?: string;
+}) => import("@tanstack/react-query").UseQueryResult<CloudObjectList, Error>;
+/** Whether the source's credential is referenced and resolvable — never its value. */
+export declare const useCredentialDiagnostics: (sourceUid?: string) => import("@tanstack/react-query").UseQueryResult<CredentialDiagnostics, Error>;
+/** Try the bucket with the credential attached; the answer is a verdict. */
+export declare const useTestCloudConnection: () => import("@tanstack/react-query").UseMutationResult<ConnectionTest, Error, string, unknown>;
+/** Every Dataset publication, for the Library. */
+export declare const usePublishedDatasets: () => import("@tanstack/react-query").UseQueryResult<DatasetPublicationList, Error>;
+/** The tools and resources the server behind a source offers. */
+export declare const useMcpTools: (sourceUid?: string) => import("@tanstack/react-query").UseQueryResult<McpToolManifest, Error>;
+/** Try the server through the source; the answer is a verdict. */
+export declare const useMcpHealth: () => import("@tanstack/react-query").UseMutationResult<McpHealth, Error, string, unknown>;
+export type McpSessionListFilters = {
+    sourceUid?: string;
+    active?: boolean;
+};
+/**
+ * The sessions the caller opened, optionally narrowed to one source or to
+ * the active ones. The contract lists them whole; the narrowing is here.
+ */
+export declare const useMcpSessions: (filters?: McpSessionListFilters, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpSessionList, Error>;
+export declare const useMcpSession: (sessionUid?: string) => import("@tanstack/react-query").UseQueryResult<McpSession, Error>;
+export declare const useCreateMcpSession: () => import("@tanstack/react-query").UseMutationResult<McpSession, Error, {
+    request: McpSessionCreate;
+    idempotencyKey: string;
+}, unknown>;
+export declare const useRevokeMcpSession: () => import("@tanstack/react-query").UseMutationResult<McpSession, Error, string, unknown>;
+/**
+ * One call, watched until the service is done with it.
+ *
+ * A call that is pending approval or running is polled; a terminal one is
+ * not, so a page that shows a finished call does not keep asking.
+ */
+export declare const useMcpCall: (sessionUid?: string, callUid?: string) => import("@tanstack/react-query").UseQueryResult<McpCall, Error>;
+/** The calls made through a session — the provenance of what they acquired. */
+export declare const useMcpCalls: (sessionUid?: string) => import("@tanstack/react-query").UseQueryResult<McpCallList, Error>;
+export declare const useCallMcpTool: () => import("@tanstack/react-query").UseMutationResult<McpCall, Error, {
+    sessionUid: string;
+    request: McpCallCreate;
+}, unknown>;
+export type McpApprovalListFilters = {
+    status?: McpApprovalStatus;
+    sourceUid?: string;
+};
+/**
+ * The approvals waiting on the caller, or those already decided. The
+ * contract filters on the status alone; a source narrows the answer here.
+ */
+export declare const useMcpApprovals: (status?: McpApprovalStatus | undefined, filters?: Omit<McpApprovalListFilters, "status">, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpApprovalList, Error>;
+/** Approve or reject a pending call; the affected call is refreshed. */
+export declare const useDecideMcpApproval: () => import("@tanstack/react-query").UseMutationResult<McpApproval, Error, {
+    approvalUid: string;
+    decision: "approve" | "reject";
+    note?: string;
+}, unknown>;
+/** The tables and columns a source exposes; asked once, then kept. */
+export declare const useDatasourceSchema: (sourceUid?: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<DatasourceSchema, Error>;
+/** What the source may be asked, and how the answer can travel. */
+export declare const useDatasourceCapabilities: (sourceUid?: string) => import("@tanstack/react-query").UseQueryResult<DatasourceCapabilities, Error>;
+/** Try the database through the source; the answer is a verdict. */
+export declare const useTestDatasource: () => import("@tanstack/react-query").UseMutationResult<DatasourceTest, Error, string, unknown>;
+/** Submit a statement. The answer is the job; `useDatasourceQuery` follows it. */
+export declare const useCreateDatasourceQuery: () => import("@tanstack/react-query").UseMutationResult<DatasourceQuery, Error, {
+    sourceUid: string;
+    request: DatasourceQueryCreate;
+    idempotencyKey: string;
+}, unknown>;
+/**
+ * One query job, polled while it can still change.
+ *
+ * A pending or running query is asked about every second; a finished one is
+ * not, so a page that shows a result does not keep asking.
+ */
+export declare const useDatasourceQuery: (queryUid?: string) => import("@tanstack/react-query").UseQueryResult<DatasourceQuery, Error>;
+/** The queries run against a source, newest first: its history. */
+export declare const useDatasourceQueries: (sourceUid?: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<DatasourceQueryList, Error>;
+/** Ask for a query to stop; the shared job record is refreshed. */
+export declare const useCancelDatasourceQuery: () => import("@tanstack/react-query").UseMutationResult<DatasourceQuery, Error, string, unknown>;
+/** The bytes of a result, or a range of them — a preview, or a resume. */
+export declare const useDownloadDatasourceQueryResults: () => import("@tanstack/react-query").UseMutationResult<DatasourceQueryResultBytes, Error, {
+    queryUid: string;
+    range?: string;
+}, unknown>;
+/** Keep a result as a Dataset revision; the Dataset's revisions refresh. */
+export declare const useSaveQueryAsDataset: () => import("@tanstack/react-query").UseMutationResult<DatasetRevision, Error, {
+    queryUid: string;
+    datasetUid: string;
+    path: string;
+}, unknown>;
+/** A Flight ticket for a result, for a client inside a sandbox. */
+export declare const useCreateDatasourceQueryTicket: () => import("@tanstack/react-query").UseMutationResult<CapabilityTicket, Error, {
+    queryUid: string;
+    request?: CapabilityTicketRequest;
+}, unknown>;
+/**
+ * The gateway as last heard, polled on a bounded interval.
+ *
+ * The previous answer stays on screen while the next is fetched — a status
+ * that blinks to nothing every ten seconds reads as flapping — and a
+ * gateway that is revoked is not polled: nothing will change on its own.
+ */
+export declare const useDataserverStatus: (sourceUid?: string, options?: {
+    enabled?: boolean;
+    intervalMs?: number;
+}) => import("@tanstack/react-query").UseQueryResult<DataServerStatus, Error>;
+export type DataserverTransition = 'drain' | 'resume' | 'revoke';
+/** Drain, resume or revoke a gateway; its status and its record refresh. */
+export declare const useDataserverAction: () => import("@tanstack/react-query").UseMutationResult<DataServerStatus, Error, {
+    sourceUid: string;
+    action: DataserverTransition;
+}, unknown>;
+/** Try the gateway on Flight and on the HTTPS fallback; the answer is a verdict. */
+export declare const useTestDataserver: () => import("@tanstack/react-query").UseMutationResult<DataServerConnectivity, Error, string, unknown>;
+/** A new certificate from a CSR; the old one stays valid while it overlaps. */
+export declare const useRotateDataserverIdentity: () => import("@tanstack/react-query").UseMutationResult<IssuedIdentity, Error, {
+    sourceUid: string;
+    csr: string;
+}, unknown>;
+/**
+ * What a running Runtime is granted, and what has arrived.
+ *
+ * Polled while the platform is still applying a change and left alone once it
+ * has settled: a mount takes a second or two, and a runtime lives for hours.
+ */
+export declare const useRuntimeMounts: (runtimeName?: string, enabled?: boolean) => import("@tanstack/react-query").UseQueryResult<RuntimeMounts, Error>;
+/**
+ * Mount the caller's home folders into a Runtime that is already running.
+ *
+ * Which folders is not a parameter: the platform resolves the caller's own
+ * memberships. A Runtime that cannot take a mount answers with the reason —
+ * 409 for a sandbox created without the gateway, 504 when the platform could
+ * not confirm it — and the caller shows that rather than a generic failure.
+ */
+export declare const useAttachRuntimeMounts: () => import("@tanstack/react-query").UseMutationResult<RuntimeMounts, Error, string, unknown>;
+/** Take one folder out of a running Runtime, by the name it appears under. */
+export declare const useDetachRuntimeMount: () => import("@tanstack/react-query").UseMutationResult<RuntimeMounts, Error, {
+    runtimeName: string;
+    target: string;
+}, unknown>;
+export {};