@datalayer/core 1.1.60 → 1.2.10

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,315 @@
+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 DomainVerification, type IdentityProvider, type IdentityProviderDraft } from '../api/iam/identityProviders';
+import type { MintedScimToken, ScimToken } from '../api/iam/scimTokens';
+import { type AdmittedClients, 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>;
+/**
+ * Disconnect every agent of this person — and so force the next
+ * authorization through the consent screen.
+ *
+ * The grant *is* the consent, so there is no separate "ask again" to keep in
+ * step: ending them all is what forcing re-consent means.
+ */
+export declare const useDisconnectEveryAgent: () => import("@tanstack/react-query").UseMutationResult<{
+    success: boolean;
+    revoked: number;
+    message?: string;
+}, Error, void, unknown>;
+/** The same for one team's agents, for whoever may manage that team. */
+export declare const useDisconnectEveryAgentInTeam: () => import("@tanstack/react-query").UseMutationResult<{
+    success: boolean;
+    revoked: number;
+    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 organization's identity providers, disabled ones included. */
+export declare const useIdentityProviders: (orgUid: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<IdentityProvider[], Error>;
+export declare const useCreateIdentityProvider: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<IdentityProvider, Error, IdentityProviderDraft, unknown>;
+export declare const useUpdateIdentityProvider: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<IdentityProvider, Error, {
+    uid: string;
+    provider: IdentityProviderDraft;
+}, unknown>;
+export declare const useSetIdentityProviderEnabled: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<IdentityProvider, Error, {
+    uid: string;
+    enabled: boolean;
+}, unknown>;
+/**
+ * What one layer's `allowedClients` entries actually name.
+ *
+ * Deliberately *not* folded into `useMcpPolicyLayer`. That query is read
+ * whenever a policy form mounts; this one may make the server fetch a client
+ * document per entry, and an editor typing in a textarea must not set that
+ * off on every keystroke — so it is fetched from what is **stored**, and goes
+ * stale until the draft is saved.
+ */
+export declare const useAdmittedClients: (scope: McpPolicyScope, subjectUid: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<AdmittedClients, Error>;
+/**
+ * One organization's SCIM tokens, revoked ones included.
+ *
+ * Revoked ones are *not* filtered out here. A console that hid them would
+ * make an organization whose every token is revoked look identical to one
+ * that never had any — and those are different problems with different
+ * fixes, only one of which is "nobody is being deprovisioned right now".
+ */
+export declare const useScimTokens: (orgUid: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<ScimToken[], Error>;
+/**
+ * Mint one. The secret is in the result and nowhere else, ever again.
+ *
+ * The mutation result is deliberately not written into the query cache: a
+ * secret that lived in a cache would be re-rendered on every refetch of the
+ * list, and outlive the dialog it was shown in.
+ */
+export declare const useCreateScimToken: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<MintedScimToken, Error, string, unknown>;
+export declare const useRotateScimToken: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<MintedScimToken, Error, string, unknown>;
+export declare const useRevokeScimToken: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<ScimToken, Error, string, unknown>;
+export declare const useDeleteIdentityProvider: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+/**
+ * What to publish in DNS, fetched on demand rather than kept fresh.
+ *
+ * A mutation, not a query with a `refetch`: this is asked for once when
+ * somebody opens the verification panel, and the value never changes for a
+ * given provider and domain — what changes is `verified`, which the
+ * `verify` call below answers directly from the provider it returns.
+ */
+export declare const useDomainVerification: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<{
+    verification: DomainVerification;
+    verified: boolean;
+}, Error, {
+    uid: string;
+    domain: string;
+}, unknown>;
+export declare const useVerifyDomain: (orgUid: string) => import("@tanstack/react-query").UseMutationResult<IdentityProvider, Error, {
+    uid: string;
+    domain: 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>;