@datalayer/core 1.1.60 → 1.2.10

package/lib/hooks/useMobile.js

@@ -2,11 +2,6 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2024-2025 Datalayer, Inc.
- *
- * BSD 3-Clause License
- */
 import * as React from 'react';
 const MOBILE_BREAKPOINT = 768;
 export function useIsMobile() {

package/lib/hooks/useNavigate.d.ts

@@ -1,6 +1,44 @@
+export interface NavigateOptions {
+    /** Replace the current history entry instead of pushing one. */
+    replace?: boolean;
+    /** History state to carry to the destination. */
+    state?: unknown;
+    /** Open the destination in a new tab and leave this one where it is. */
+    newTab?: boolean;
+    /** Scroll to the top on arrival; on by default. */
+    scroll?: boolean;
+    /**
+     * Close the layout's side portals on the way; on by default. Only the
+     * history API host has them.
+     */
+    resetPortals?: boolean;
+}
 /**
- * Main navigation hook that provides a universal navigate function
- * Works with React Router, Next.js, or native browser navigation
+ * The part of a click (or a key press, from a menu) the hook looks at. A
+ * structural type, so React's synthetic events and DOM events both fit.
  */
-export declare const useNavigate: () => (location: string | number, optionsOrEvent?: any, resetPortals?: boolean, extraOptions?: any) => void;
+export interface NavigateEvent {
+    preventDefault: () => void;
+    metaKey?: boolean;
+    ctrlKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    button?: number;
+    currentTarget?: unknown;
+    target?: unknown;
+}
+export type NavigateTarget = string | number;
+/**
+ * The call shapes accepted, old and new:
+ * - `navigate(to, options?)`
+ * - `navigate(to, event, options?)`
+ * - `navigate(to, event, resetPortals, options?)` (legacy)
+ * - `navigate(to, resetPortals, options?)` (legacy)
+ */
+export type Navigate = (to: NavigateTarget, optionsOrEvent?: NavigateOptions | NavigateEvent | boolean, third?: boolean | NavigateOptions, fourth?: NavigateOptions) => void;
+/** Whether `event` is a click meant to open a new tab or window. */
+export declare function isNewTabClick(event: NavigateEvent): boolean;
+/** Open `to` in a new tab, without handing it this window. */
+export declare function openInNewTab(to: string): void;
+export declare const useNavigate: () => Navigate;
 export default useNavigate;

package/lib/hooks/useNavigate.js

@@ -2,88 +2,142 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import { useCallback } from 'react';
+/**
+ * Navigation for any host: React Router when the app runs under one, the
+ * history API otherwise.
+ *
+ * One function, `navigate(to, …)`, with the click event as an optional second
+ * argument. Pass it and a click behaves the way a browser link does: a plain
+ * click navigates in place and stops the anchor's own navigation; a modifier
+ * click (⌘, Ctrl, Shift, Alt) or a middle click opens the target in a new tab
+ * — through the browser when the click was on a link to that target, through
+ * `window.open` otherwise, so a button gets it too. `newTab` in the options
+ * opens a new tab outright.
+ *
+ * @module hooks/useNavigate
+ */
+import { useCallback, useMemo } from 'react';
 import { useLayoutStore } from '../state/index.js';
 import { createNativeNavigate } from '../navigation/adapters/native.js';
 // Import React Router hooks from our wrapper
 import { useNavigateRR } from '../navigation/adapters/react-router.js';
-// Import Next.js hooks from our wrapper
-// Currently not used but kept for future Next.js support
-// import { useRouterNext } from '../navigation/adapters/nextjs.js';
+/** Whether `event` is a click meant to open a new tab or window. */
+export function isNewTabClick(event) {
+    return (!!event.metaKey ||
+        !!event.ctrlKey ||
+        !!event.shiftKey ||
+        !!event.altKey ||
+        event.button === 1);
+}
+/** The absolute URL `to` names from the current page. */
+const resolveUrl = (to) => new URL(to, window.location.href).href;
+/** Open `to` in a new tab, without handing it this window. */
+export function openInNewTab(to) {
+    window.open(resolveUrl(to), '_blank', 'noopener,noreferrer');
+}
 /**
- * Main navigation hook that provides a universal navigate function
- * Works with React Router, Next.js, or native browser navigation
+ * Whether `event` happened on a link whose `href` already is `to`: then the
+ * browser opens the new tab itself, and nothing needs doing.
  */
+function isLinkTo(event, to) {
+    const origin = (event.currentTarget ?? event.target);
+    const anchor = origin && typeof origin.closest === 'function'
+        ? origin.closest('a[href]')
+        : null;
+    if (!anchor) {
+        return false;
+    }
+    try {
+        return resolveUrl(anchor.getAttribute('href') ?? '') === resolveUrl(to);
+    }
+    catch {
+        return false;
+    }
+}
+const isEvent = (value) => !!value && typeof value.preventDefault === 'function';
+function parseCall(optionsOrEvent, third, fourth) {
+    if (isEvent(optionsOrEvent)) {
+        const options = typeof third === 'boolean'
+            ? { resetPortals: third, ...(fourth ?? {}) }
+            : { ...(third ?? {}), ...(fourth ?? {}) };
+        return { event: optionsOrEvent, options };
+    }
+    if (typeof optionsOrEvent === 'boolean') {
+        return {
+            options: {
+                resetPortals: optionsOrEvent,
+                ...(typeof third === 'object' ? third : {}),
+                ...(fourth ?? {}),
+            },
+        };
+    }
+    return { options: { ...(optionsOrEvent ?? {}) } };
+}
 export const useNavigate = () => {
     const layoutStore = useLayoutStore();
     // Detect environment
     const isNextJs = typeof window !== 'undefined' && !!window.__NEXT_DATA__;
     const isClient = typeof window !== 'undefined';
-    // Try to use React Router's useNavigate if available
+    // React Router's navigate when the app runs under a Router, else nothing.
     let rrNavigate = null;
-    let isReactRouter = false;
     if (!isNextJs && useNavigateRR && isClient) {
         try {
             // eslint-disable-next-line react-hooks/rules-of-hooks
             rrNavigate = useNavigateRR();
-            isReactRouter = !!rrNavigate;
         }
         catch {
             // Not in a Router context
         }
     }
-    // If React Router is available, return it directly (wrapped for consistency)
-    if (isReactRouter && rrNavigate) {
-        // eslint-disable-next-line react-hooks/rules-of-hooks
-        return useCallback((to, options) => {
-            // Scroll to top when navigating (except for history navigation)
-            if (typeof to === 'string') {
-                window.scrollTo(0, 0);
-                document.body.scrollTop = 0;
+    const nativeNavigate = useMemo(() => createNativeNavigate(), []);
+    return useCallback((to, optionsOrEvent, third, fourth) => {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        const { event, options } = parseCall(optionsOrEvent, third, fourth);
+        // History navigation (e.g. -1 to go back).
+        if (typeof to === 'number') {
+            event?.preventDefault();
+            if (rrNavigate) {
+                rrNavigate(to);
+            }
+            else {
+                window.history.go(to);
             }
-            // For React Router, pass through directly
-            return rrNavigate(to, options);
-        }, [rrNavigate]);
-    }
-    // Otherwise use native navigation with our custom behavior
-    const baseNavigate = createNativeNavigate();
-    // Wrap with our custom behavior for native navigation
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const navigate = useCallback((location, optionsOrEvent, resetPortals = true, extraOptions) => {
-        // Handle number for history navigation (e.g., -1 to go back)
-        if (typeof location === 'number') {
-            window.history.go(location);
             return;
         }
-        // Handle different call signatures for native navigation
-        let options = undefined;
-        let event = undefined;
-        if (optionsOrEvent && optionsOrEvent.preventDefault) {
-            // Legacy signature with event as second parameter
-            event = optionsOrEvent;
-            options = extraOptions;
+        // A new tab was asked for with the click. A link to that very place
+        // gets it from the browser; a button, or a link elsewhere, from us.
+        if (event && isNewTabClick(event)) {
+            if (!isLinkTo(event, to)) {
+                event.preventDefault();
+                openInNewTab(to);
+            }
+            return;
         }
-        else if (typeof optionsOrEvent === 'boolean') {
-            // Legacy signature with resetPortals as second parameter
-            resetPortals = optionsOrEvent;
-            options = extraOptions;
+        if (options.newTab) {
+            event?.preventDefault();
+            openInNewTab(to);
+            return;
         }
-        else {
-            // Standard signature with options as second parameter
-            options = optionsOrEvent;
+        event?.preventDefault();
+        if (options.scroll !== false) {
+            window.scrollTo(0, 0);
+            document.body.scrollTop = 0;
         }
-        if (event) {
-            event.preventDefault();
+        if (rrNavigate) {
+            rrNavigate(to, { replace: options.replace, state: options.state });
+            return;
         }
-        if (resetPortals) {
+        if (options.resetPortals !== false) {
             layoutStore.resetLeftPortal();
             layoutStore.resetRightPortal();
         }
-        window.scrollTo(0, 0);
-        document.body.scrollTop = 0;
-        // Use native navigation
-        baseNavigate(location, options);
-    }, [baseNavigate, layoutStore]);
-    return navigate;
+        nativeNavigate(to, {
+            replace: options.replace,
+            state: options.state,
+            scroll: options.scroll,
+        });
+    }, [rrNavigate, nativeNavigate, layoutStore]);
 };
 export default useNavigate;

package/lib/hooks/usePrincipalCacheStore.js

@@ -3,6 +3,7 @@
  * Distributed under the terms of the Modified BSD License.
  */
 import { create } from 'zustand';
+import { registerSessionState } from '../state/sessionEnd.js';
 /** Build the cache key for a principal. */
 export function principalCacheKey(kind, uid) {
     return `${kind}:${String(uid || '').trim()}`;
@@ -94,3 +95,5 @@ export const usePrincipalCacheStore = create((set, get) => ({
     reset: () => set({ principals: {} }),
 }));
 export default usePrincipalCacheStore;
+// What one session resolved is not the next one's to paint.
+registerSessionState({ forget: () => usePrincipalCacheStore.getState().reset() });

package/lib/hooks/usePrincipalStore.js

@@ -5,6 +5,7 @@
 import { create } from 'zustand';
 import { createJSONStorage, persist } from 'zustand/middleware';
 import { useUsageRefreshStore } from './useUsageRefreshStore.js';
+import { registerSessionState } from '../state/sessionEnd.js';
 const PRINCIPAL_CONTEXT_COOKIE = 'datalayer-principal-context';
 const PRINCIPAL_CONTEXT_COOKIE_MAX_AGE = 60 * 60 * 24 * 365;
 const readPrincipalContextCookie = () => {
@@ -182,3 +183,5 @@ export const usePrincipalStore = create()(persist(set => ({
     },
 }));
 export default usePrincipalStore;
+// The principal selected is the signed-in person's: forgotten when the session ends.
+registerSessionState({ forget: () => usePrincipalStore.getState().resetPrincipal() });

package/lib/hooks/useProjectStore.d.ts

@@ -10,8 +10,8 @@ import type { IKernelConnection } from '@jupyterlab/services/lib/kernel/kernel';
 export type ProjectRuntimeEntry = {
     /** The Jupyter session connection (notebook ↔ kernel bridge). */
     sessionConnection?: Session.ISessionConnection;
-    /** The assigned agent pod name (mirrors project.attachedAgentPodName). */
-    agentPodName?: string;
+    /** The assigned agent pod name (mirrors project.attachedAgentRuntimeName). */
+    agentRuntimeName?: string;
     /** Display name of the assigned agent. */
     agentName?: string;
     /** Agent runtime status (running, starting, terminated, etc.). */
@@ -29,7 +29,7 @@ export type ProjectStoreState = {
     /** Set or update the session connection for a project. */
     setSessionConnection: (projectId: string, sessionConnection: Session.ISessionConnection | undefined) => void;
     /** Set the assigned agent info for a project. */
-    setAgent: (projectId: string, agentPodName: string | undefined, agentName?: string, agentStatus?: string, agentSpecId?: string) => void;
+    setAgent: (projectId: string, agentRuntimeName: string | undefined, agentName?: string, agentStatus?: string, agentSpecId?: string) => void;
     /** Remove all runtime state for a project (e.g. on unmount). */
     clearProject: (projectId: string) => void;
     /** Get the kernel connection for a project, or undefined. */

package/lib/hooks/useProjectStore.js

@@ -34,19 +34,19 @@ export const useProjectStore = create()((set, get) => ({
             },
         },
     })),
-    setAgent: (projectId, agentPodName, agentName, agentStatus, agentSpecId) => set(state => ({
+    setAgent: (projectId, agentRuntimeName, agentName, agentStatus, agentSpecId) => set(state => ({
         projects: {
             ...state.projects,
             [projectId]: {
                 ...state.projects[projectId],
-                agentPodName,
+                agentRuntimeName,
                 agentName,
                 // When removing the agent, also clear the status.
                 // When setting, use provided status or preserve existing.
-                agentStatus: agentPodName !== undefined
+                agentStatus: agentRuntimeName !== undefined
                     ? (agentStatus ?? state.projects[projectId]?.agentStatus)
                     : undefined,
-                agentSpecId: agentPodName !== undefined
+                agentSpecId: agentRuntimeName !== undefined
                     ? (agentSpecId ?? state.projects[projectId]?.agentSpecId)
                     : undefined,
             },

package/lib/hooks/useRef.d.ts

@@ -7,4 +7,4 @@ import React from 'react';
  * @param providedRef The ref to use - if undefined, will use the ref from a call to React.useRef
  * @type TRef The type of the RefObject which should be created.
  */
-export declare function useProvidedRefOrCreate<TRef>(providedRef?: React.RefObject<TRef>): React.RefObject<TRef>;
+export declare function useProvidedRefOrCreate<TRef>(providedRef?: React.RefObject<TRef | null>): React.RefObject<TRef | null>;

package/lib/hooks/useRef.js

@@ -11,6 +11,9 @@ import { useRef } from 'react';
  * @param providedRef The ref to use - if undefined, will use the ref from a call to React.useRef
  * @type TRef The type of the RefObject which should be created.
  */
+// React 19 types `useRef<T>(null)` as `RefObject<T | null>`, so both the
+// accepted and returned ref are nullable here. Primer 37 still declares the
+// React 18 shape, so its call sites cast at the boundary.
 export function useProvidedRefOrCreate(providedRef) {
     const createdRef = useRef(null);
     return providedRef ?? createdRef;

package/lib/hooks/useScreencapture.d.ts

@@ -1,3 +1,4 @@
+import type { JSX } from 'react';
 import { ReactNode } from 'react';
 export type ScreencaptureContextType = {
     closeScreencapture: () => void;
@@ -15,4 +16,4 @@ export type IScreencaptureProviderProps = {
     disableDarken?: boolean;
     screenshotSurface?: (qfds: any) => JSX.Element;
 };
-export declare function ScreencaptureProvider({ children, zIndex, disableDarken, screenshotSurface, }: IScreencaptureProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function ScreencaptureProvider({ children, zIndex, disableDarken, screenshotSurface, }: IScreencaptureProviderProps): JSX.Element;

package/lib/hooks/useScreencapture.js

@@ -1,8 +1,4 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 import { createContext, useState, useContext } from 'react';
 import { LayoutScreencapture } from './layouts/index.js';
 export const ScreencaptureContext = createContext({

package/lib/hooks/useSpaceCacheStore.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A resolved space, kept in memory.
+ *
+ * The companion of {@link usePrincipalCacheStore}, for the same reason: a
+ * table of a hundred notebooks sitting in three spaces should resolve the
+ * three names once, and the next view that shows one of those spaces should
+ * paint it before any request has returned. Partial snapshots merge — a blank
+ * never overwrites a value already known — so what is known of a space
+ * accumulates across the views that saw it.
+ */
+export type CachedSpace = {
+    /** The space uid: what the spacer API names a space by. */
+    uid: string;
+    /**
+     * The space's internal Solr id. An item is a nested child of its space and
+     * names it only by this (`_root_`), so a row that knows nothing else can
+     * still be matched to its space.
+     */
+    rootId?: string;
+    handle?: string;
+    displayName?: string;
+    description?: string;
+    variant?: string;
+    isPublic?: boolean;
+    /** The account the space is addressed under: its organization, else its owner. */
+    accountHandle?: string;
+    /** Timestamp (ms) of the last time this entry changed. */
+    updatedAt?: number;
+};
+type SpaceCacheState = {
+    /** Cached spaces keyed by uid. */
+    spaces: Record<string, CachedSpace>;
+    /** Space uids keyed by the Solr id items carry as `_root_`. */
+    uidByRootId: Record<string, string>;
+    /** Read a cached space by uid, if present. */
+    getSpace: (uid: string) => CachedSpace | undefined;
+    /** Read a cached space by the Solr id an item names it by, if present. */
+    getSpaceByRootId: (rootId: string) => CachedSpace | undefined;
+    /**
+     * Merge a (possibly partial) space snapshot into the cache. Existing
+     * meaningful values are kept when the incoming snapshot omits them.
+     */
+    upsertSpace: (entry: CachedSpace) => void;
+    /** Remove a single cached space (e.g. after it was renamed or deleted). */
+    clearSpace: (uid: string) => void;
+    /** Clear the entire cache. */
+    reset: () => void;
+};
+export declare const useSpaceCacheStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SpaceCacheState>>;
+export default useSpaceCacheStore;

package/lib/hooks/useSpaceCacheStore.js

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { create } from 'zustand';
+import { registerSessionState } from '../state/sessionEnd.js';
+const MERGEABLE_KEYS = [
+    'rootId',
+    'handle',
+    'displayName',
+    'description',
+    'variant',
+    'isPublic',
+    'accountHandle',
+];
+function hasMeaningfulValue(value) {
+    if (value === undefined || value === null) {
+        return false;
+    }
+    if (typeof value === 'string') {
+        return value.trim().length > 0;
+    }
+    return true;
+}
+export const useSpaceCacheStore = create((set, get) => ({
+    spaces: {},
+    uidByRootId: {},
+    getSpace: uid => {
+        const key = String(uid || '').trim();
+        return key ? get().spaces[key] : undefined;
+    },
+    getSpaceByRootId: rootId => {
+        const key = String(rootId || '').trim();
+        const uid = key ? get().uidByRootId[key] : undefined;
+        return uid ? get().spaces[uid] : undefined;
+    },
+    upsertSpace: entry => {
+        const uid = String(entry.uid || '').trim();
+        if (!uid) {
+            return;
+        }
+        const existing = get().spaces[uid];
+        const merged = { ...existing, uid };
+        for (const field of MERGEABLE_KEYS) {
+            const incoming = entry[field];
+            if (hasMeaningfulValue(incoming)) {
+                merged[field] = incoming;
+            }
+        }
+        // Nothing new: skip the update, so every mounted SpaceDisplay does not
+        // re-render for a snapshot it already has.
+        if (existing &&
+            MERGEABLE_KEYS.every(field => merged[field] === existing[field])) {
+            return;
+        }
+        merged.updatedAt = Date.now();
+        const rootId = String(merged.rootId || '').trim();
+        set(state => ({
+            spaces: { ...state.spaces, [uid]: merged },
+            uidByRootId: rootId && state.uidByRootId[rootId] !== uid
+                ? { ...state.uidByRootId, [rootId]: uid }
+                : state.uidByRootId,
+        }));
+    },
+    clearSpace: uid => {
+        const key = String(uid || '').trim();
+        set(state => {
+            const existing = state.spaces[key];
+            if (!existing) {
+                return state;
+            }
+            const spaces = { ...state.spaces };
+            delete spaces[key];
+            const uidByRootId = { ...state.uidByRootId };
+            if (existing.rootId && uidByRootId[existing.rootId] === key) {
+                delete uidByRootId[existing.rootId];
+            }
+            return { spaces, uidByRootId };
+        });
+    },
+    reset: () => set({ spaces: {}, uidByRootId: {} }),
+}));
+export default useSpaceCacheStore;
+// What one session resolved is not the next one's to paint.
+registerSessionState({ forget: () => useSpaceCacheStore.getState().reset() });

package/lib/hooks/useToast.js

@@ -1,8 +1,4 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 import React from 'react';
 import { toast } from 'react-toastify';
 import { Button } from '@primer/react';

package/lib/hooks/useVisibilityObserver.d.ts

@@ -2,4 +2,4 @@ import { RefObject } from 'react';
 export type VisibilityMap = {
     [key: string]: boolean;
 };
-export declare function useVisibilityObserver(navigationRef: RefObject<HTMLUListElement>, children: any): VisibilityMap[];
+export declare function useVisibilityObserver(navigationRef: RefObject<HTMLUListElement | null>, children: any): VisibilityMap[];

package/lib/index.d.ts

@@ -3,10 +3,13 @@ export * from './utils';
 export * from './state';
 export * from './navigation';
 export * from './hooks';
-export { requestDatalayerAPI, RunResponseError, NetworkError, } from './api/DatalayerApi';
+export { requestDatalayerAPI, requestDatalayerAPIWithResponse, RunResponseError, NetworkError, } from './api/DatalayerApi';
 export type { IRequestDatalayerAPIOptions } from './api/DatalayerApi';
+export type { IDatalayerAPIResponse } from './api/DatalayerApi';
 export { API_BASE_PATHS } from './api/constants';
 export * as iamApi from './api/iam';
+export * as contentsApi from './api/contents';
 export * from './client';
+export * from './models/contents';
 export * from './otel';
 export * from './views';

package/lib/index.js

@@ -10,10 +10,12 @@ export * from './state/index.js';
 export * from './navigation/index.js';
 export * from './hooks/index.js';
 // Export APIs.
-export { requestDatalayerAPI, RunResponseError, NetworkError, } from './api/DatalayerApi.js';
+export { requestDatalayerAPI, requestDatalayerAPIWithResponse, RunResponseError, NetworkError, } from './api/DatalayerApi.js';
 export { API_BASE_PATHS } from './api/constants.js';
 export * as iamApi from './api/iam/index.js';
+export * as contentsApi from './api/contents/index.js';
 export * from './client/index.js';
+export * from './models/contents/index.js';
 // OTEL observability components, hooks, and types
 export * from './otel/index.js';
 // Reusable views (sign-in pages, etc.)

package/lib/mocks/components/FlashMock.d.ts

@@ -1,2 +1,2 @@
-export declare const FlashMock: () => import("react/jsx-runtime").JSX.Element;
+export declare const FlashMock: () => import("react").JSX.Element;
 export default FlashMock;

package/lib/mocks/views/ActionMenuMock.d.ts

@@ -1,5 +1,5 @@
 type Props = {
     title: string;
 };
-export declare const ActionMenuMock: (props: Props) => import("react/jsx-runtime").JSX.Element;
+export declare const ActionMenuMock: (props: Props) => import("react").JSX.Element;
 export default ActionMenuMock;

package/lib/mocks/views/ChartMock.d.ts

@@ -1,5 +1,5 @@
 type Props = {
     title: string;
 };
-export declare const ChartMock: (props: Props) => import("react/jsx-runtime").JSX.Element;
+export declare const ChartMock: (props: Props) => import("react").JSX.Element;
 export default ChartMock;

package/lib/mocks/views/DashboardMock.d.ts

@@ -1,2 +1,2 @@
-export declare const DashboardMock: () => import("react/jsx-runtime").JSX.Element;
+export declare const DashboardMock: () => import("react").JSX.Element;
 export default DashboardMock;

package/lib/mocks/views/FormMock.d.ts

@@ -1,5 +1,5 @@
 type Props = {
     title: string;
 };
-export declare const FormMock: (props: Props) => import("react/jsx-runtime").JSX.Element;
+export declare const FormMock: (props: Props) => import("react").JSX.Element;
 export default FormMock;

package/lib/mocks/views/TableMock.d.ts

@@ -1,5 +1,5 @@
 type Props = {
     title: string;
 };
-export declare const TableMock: (props: Props) => import("react/jsx-runtime").JSX.Element;
+export declare const TableMock: (props: Props) => import("react").JSX.Element;
 export default TableMock;

package/lib/mocks/views/WipMock.d.ts

@@ -1,5 +1,5 @@
 type Props = {
     title: string;
 };
-export declare const WipMock: (props: Props) => import("react/jsx-runtime").JSX.Element;
+export declare const WipMock: (props: Props) => import("react").JSX.Element;
 export default WipMock;

package/lib/models/Credits.d.ts

@@ -25,6 +25,22 @@ export interface ICredits {
      */
     last_update: string;
 }
+/**
+ * The credits an account can still spend.
+ *
+ * `credits` means one of two things depending on whether a quota is set: what
+ * is left, or what has been consumed against the quota. IAM omits `quota`
+ * entirely for an account without one, so an absent quota is read the same as
+ * an explicit `null` — testing only against `null` let `undefined` take the
+ * quota branch and produced `NaN`, which then travelled silently into every
+ * reader of this number.
+ *
+ * Outstanding reservations are already committed, so they are subtracted:
+ * what is returned is what a new reservation may still claim.
+ */
+export declare const availableCredits: (credits: Pick<ICredits, "credits" | "quota">, reservations?: readonly {
+    credits: number;
+}[]) => number;
 export interface ICheckoutPortal {
     /**
      * External checkout portal URL to open in a new tab.