@datalayer/core 1.1.59 → 1.1.66

package/lib/hooks/useFocusTrap.d.ts

@@ -4,12 +4,12 @@ export interface FocusTrapHookSettings {
      * Ref that will be used for the trapping container. If not provided, one will
      * be created by this hook and returned.
      */
-    containerRef: React.RefObject<HTMLElement>;
+    containerRef: React.RefObject<HTMLElement | null>;
     /**
      * Ref for the element that should receive focus when the focus trap is first enabled.
      * If not provided, one will be created by this hook and returned. Its use is optional.
      */
-    initialFocusRef?: React.RefObject<HTMLElement>;
+    initialFocusRef?: React.RefObject<HTMLElement | null>;
     /**
      * Set to true to disable the focus trap and clean up listeners. Can be re-enabled at any time.
      */
@@ -25,6 +25,6 @@ export interface FocusTrapHookSettings {
  * @param settings &lcub;FocusTrapHookSettings&rcub;
  */
 export declare function useFocusTrap(settings?: FocusTrapHookSettings, dependencies?: React.DependencyList): {
-    containerRef: React.RefObject<HTMLElement> | undefined;
-    initialFocusRef: React.RefObject<HTMLElement> | undefined;
+    containerRef: React.RefObject<HTMLElement | null> | undefined;
+    initialFocusRef: React.RefObject<HTMLElement | null> | undefined;
 };

package/lib/hooks/useFocusTrap.js

@@ -13,7 +13,7 @@ export function useFocusTrap(settings, dependencies = []) {
     const containerRef = settings?.containerRef;
     const initialFocusRef = settings?.initialFocusRef;
     const disabled = settings?.disabled;
-    const abortController = React.useRef();
+    const abortController = React.useRef(undefined);
     const previousFocusedElement = React.useRef(null);
     // If we are enabling a focus trap and haven't already stored the previously focused element
     // go ahead an do that so we can restore later when the trap is disabled.

package/lib/hooks/useMcp.d.ts

@@ -0,0 +1,229 @@
+import { type McpActivity, type McpActivityFilters, type McpAuditFilters, type McpBindingListFilters, type McpGatewayVersion, type McpMetricsFilters, type McpMetricsSnapshot, type McpOrganizationOverview, type McpOrganizationUsage, type McpOrganizationOverviewFilters, type McpPolicyFilters, type McpRunLogs, type McpRunTrace, type McpTaskEvent, type McpTaskListFilters, type McpWorkerList, type McpWorkflowsHealth } from '../api/mcp';
+import { type ConnectedAgent } from '../api/iam/connectedAgents';
+import { type OrganizationTeam } from '../api/iam/organizationTeams';
+import { setAuditSettings, type McpAuditSettings } from '../api/iam/mcpAuditSettings';
+import { type McpForwarding } from '../api/mcp/forwarding';
+import { type McpAlertRuleTrial } from '../api/mcp/alerts';
+import { type McpAlertRule, type McpAlertRuleDraft } from '../api/iam/mcpAlertRules';
+import { type McpPolicy, type McpPolicyRules, type McpPolicyScope } from '../api/iam/mcpPolicy';
+import { type ServiceAgent, type ServiceAgentWithKey } from '../api/iam/serviceAgents';
+import type { McpAuditEventList, McpAuditExportFormat } from '../models/McpAuditEvent';
+import type { McpBinding, McpBindingList } from '../models/McpBinding';
+import type { McpEffectivePolicy } from '../models/McpPolicy';
+import type { McpTask, McpTaskList } from '../models/McpTask';
+export declare const useTasks: (filters?: McpTaskListFilters, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpTaskList, Error>;
+/** One task, polled every two seconds until it is terminal. */
+export declare const useTask: (taskUid?: string) => import("@tanstack/react-query").UseQueryResult<McpTask, Error>;
+export declare const useNotebookTasks: (notebookUid?: string, filters?: Pick<McpTaskListFilters, "status" | "cursor" | "limit">) => import("@tanstack/react-query").UseQueryResult<McpTaskList, Error>;
+/**
+ * The task's server-sent events, patched into the task's cache entry so
+ * every `useTask` of it updates without polling. Ends by itself when the
+ * task is terminal; the subscription closes with the component.
+ */
+export declare const useTaskEvents: (taskUid?: string, options?: {
+    enabled?: boolean;
+    onEvent?: (event: McpTaskEvent) => void;
+}) => void;
+export declare const useCancelTask: () => import("@tanstack/react-query").UseMutationResult<McpTask, Error, string, unknown>;
+export declare const useAnswerTask: () => import("@tanstack/react-query").UseMutationResult<McpTask, Error, {
+    taskUid: string;
+    input: Record<string, unknown>;
+}, unknown>;
+export declare const useBindings: (filters?: McpBindingListFilters, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpBindingList, Error>;
+export declare const useTerminateBinding: () => import("@tanstack/react-query").UseMutationResult<McpBinding, Error, string, unknown>;
+/**
+ * What is going on for the caller, refetched every ten seconds as the
+ * fallback under the ai-agents websocket, which patches the same entry.
+ */
+export declare const useMcpActivity: (filters?: McpActivityFilters, options?: {
+    enabled?: boolean;
+    pollIntervalMs?: number | false;
+}) => import("@tanstack/react-query").UseQueryResult<McpActivity, Error>;
+/** One page of the audit log; the cursor is one of the filters, as the URL keeps it. */
+export declare const useAuditEvents: (filters?: McpAuditFilters, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpAuditEventList, Error>;
+/** The whole selection as one JSONL or CSV document, on demand. */
+export declare const useAuditExport: () => import("@tanstack/react-query").UseMutationResult<string, Error, {
+    filters?: Omit<McpAuditFilters, "cursor" | "limit">;
+    format?: McpAuditExportFormat;
+}, unknown>;
+/** The effective policy for the caller, or previewed as one agent. */
+export declare const useEffectivePolicy: (agent?: string, filters?: Omit<McpPolicyFilters, "agent">, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpEffectivePolicy, Error>;
+/**
+ * The organization's MCP overview, for the console's first page.
+ *
+ * Read on demand and kept for a minute: an administrator reads it, acts, and
+ * comes back — it is not a live pane, and a page that re-asked every ten
+ * seconds would cost the gateway three bounded queries for nothing.
+ */
+export declare const useOrgMcpOverview: (orgUid?: string, filters?: McpOrganizationOverviewFilters, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpOrganizationOverview, Error>;
+/**
+ * The organization's use against its quotas, and which agents spent it.
+ *
+ * Kept for a minute like the overview, and for the same reason: an
+ * administrator reads it, acts, and comes back. A budget that re-asked every
+ * ten seconds would cost IAM a ledger query for a number that moves in
+ * credits, not in milliseconds.
+ */
+export declare const useOrgMcpUsage: (orgUid?: string, filters?: McpOrganizationOverviewFilters, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpOrganizationUsage, Error>;
+export declare const useConnectedAgents: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<ConnectedAgent[], Error>;
+/** Revoke a grant; the list and the activity are refreshed, never guessed. */
+export declare const useDisconnectAgent: () => import("@tanstack/react-query").UseMutationResult<{
+    success: boolean;
+    message?: string;
+}, Error, string, unknown>;
+/** One organization's teams, for the console's team policy page. */
+export declare const useOrganizationTeams: (orgUid: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<OrganizationTeam[], Error>;
+/**
+ * Whether the audit is reaching the organization's own system of record.
+ *
+ * Polled rather than read once: a destination that stops answering does so
+ * while somebody is looking at the page, and the point of the panel is to
+ * say when that happens.
+ */
+export declare const useMcpForwarding: (org?: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpForwarding, Error>;
+/** One organization's settings, or `null` where it has decided nothing. */
+export declare const useAuditSettings: (orgUid: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpAuditSettings | null, Error>;
+/**
+ * Change some of them. Only what is passed is sent, because IAM merges: a
+ * page editing the alert destinations must not clear a retention it never
+ * showed.
+ */
+export declare const useSetAuditSettings: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<McpAuditSettings, Error, {
+    settings: Parameters<typeof setAuditSettings>[2];
+    expectedVersion?: number;
+}, unknown>;
+/**
+ * Try a rule against current values.
+ *
+ * A mutation rather than a query: it is something somebody asks for, once,
+ * by pressing a button — and caching "what does this see now" would answer
+ * the second press with the first press's numbers.
+ */
+export declare const useTestAlertRule: () => import("@tanstack/react-query").UseMutationResult<McpAlertRuleTrial, Error, {
+    condition: string;
+    operator: string;
+    threshold: number;
+    windowSeconds: number;
+    scopeKind?: string;
+    scopeUid?: string;
+}, unknown>;
+/** One organization's alert rules, disabled ones included. */
+export declare const useAlertRules: (orgUid: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpAlertRule[], Error>;
+export declare const useCreateAlertRule: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<McpAlertRule, Error, McpAlertRuleDraft, unknown>;
+export declare const useUpdateAlertRule: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<McpAlertRule, Error, {
+    uid: string;
+    rule: McpAlertRuleDraft;
+}, unknown>;
+export declare const useDeleteAlertRule: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+/**
+ * One layer's rules, or `null` where nobody has written one.
+ *
+ * `null` is a real answer and not an error: most organizations have never
+ * written a policy, and a form needs to tell "narrows nothing" from "does
+ * not exist" — only the second has nothing to remove.
+ */
+export declare const useMcpPolicyLayer: (scope: McpPolicyScope, subjectUid: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpPolicy | null, Error>;
+/**
+ * Several layers at once, for a page that has to compare against them all.
+ *
+ * The personal policy page needs every organization a person belongs to in
+ * order to say which of their values will have no effect. One hook per
+ * organization is not something a component can do — the count changes — so
+ * they are fetched together and answered in the order asked.
+ *
+ * A layer that could not be read comes back `null`, the same as one nobody
+ * has written. That is the safe direction here: the page would rather say
+ * nothing about narrowing than invent a cap somebody does not have.
+ */
+export declare const useMcpPolicyLayers: (scope: McpPolicyScope, subjectUids: string[]) => import("@tanstack/react-query").UseQueryResult<McpPolicy | null, Error>[];
+/**
+ * Replace one layer's rules.
+ *
+ * The **effective** policy is invalidated alongside the layer: the two are
+ * the same fact read two ways, and a page still showing the old effective
+ * policy after a write is a page saying the change did not take.
+ */
+export declare const useSetMcpPolicyLayer: (scope: McpPolicyScope, subjectUid: string) => import("@tanstack/react-query").UseMutationResult<McpPolicy, Error, {
+    rules: McpPolicyRules;
+    expectedVersion?: number;
+}, unknown>;
+/** Remove one layer, so it narrows nothing again. */
+export declare const useDeleteMcpPolicyLayer: (scope: McpPolicyScope, subjectUid: string) => import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+/**
+ * One organization's service agents, revoked ones included.
+ *
+ * Keyed by the organization: two organizations' lists must never share a
+ * cache entry, or an owner of both would see one under the other's name.
+ */
+export declare const useServiceAgents: (orgUid: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<ServiceAgent[], Error>;
+/**
+ * Create one. The answer carries the key, and it is the only place it
+ * exists — so the caller must render it before doing anything else with it.
+ */
+export declare const useCreateServiceAgent: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<ServiceAgentWithKey, Error, {
+    name: string;
+    scopes: string[];
+    description?: string;
+    teamUid?: string;
+}, unknown>;
+/** Replace an agent's key; the old one stops working with the call. */
+export declare const useRotateServiceAgentKey: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<ServiceAgentWithKey, Error, string, unknown>;
+/** Stop an agent. The list is refetched rather than edited in place. */
+export declare const useRevokeServiceAgent: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<ServiceAgent, Error, string, unknown>;
+/** The spans of a run, from the task's trace id; asked again while the task runs. */
+export declare const useRunTrace: (taskUid?: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpRunTrace, Error>;
+/**
+ * The spans of one trace, for a call that finished inside its own request.
+ *
+ * Read once and kept: a finished trace does not change, and the pane that
+ * shows it is opened from an audit row rather than watched.
+ */
+export declare const useMcpTrace: (traceId?: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpRunTrace, Error>;
+/** The four SLIs and the catalog, platform-wide or for one agent or organization. */
+export declare const useMcpMetrics: (filters?: McpMetricsFilters, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpMetricsSnapshot, Error>;
+/** The log lines of a run, gateway and worker alike, by its trace. */
+export declare const useMcpLogs: (taskUid?: string, options?: {
+    enabled?: boolean;
+    limit?: number;
+    severity?: string;
+}) => import("@tanstack/react-query").UseQueryResult<McpRunLogs, Error>;
+export declare const useMcpWorkers: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpWorkerList, Error>;
+export declare const useMcpWorkflowsHealth: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<McpWorkflowsHealth, Error>;
+/** The gateway's version and resource; no token needed. */
+export declare const useMcpGatewayVersion: () => import("@tanstack/react-query").UseQueryResult<McpGatewayVersion, Error>;