@mastra/playground-ui 20.0.1 → 20.0.2

package/dist/src/domains/logs/components/log-details.d.ts

@@ -0,0 +1,12 @@
+import { LogRecord } from '../types';
+export interface LogDetailsProps {
+    log: LogRecord;
+    onClose: () => void;
+    onTraceClick?: (traceId: string) => void;
+    onSpanClick?: (traceId: string, spanId: string) => void;
+    onPrevious?: () => void;
+    onNext?: () => void;
+    collapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+}
+export declare function LogDetails({ log, onClose, onTraceClick, onSpanClick, onPrevious, onNext, collapsed: controlledCollapsed, onCollapsedChange, }: LogDetailsProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/logs/components/logs-date-range-selector.d.ts

@@ -0,0 +1,12 @@
+declare const DATE_PRESETS: {
+    label: string;
+    value: string;
+}[];
+export type LogsDatePreset = (typeof DATE_PRESETS)[number]['value'];
+export declare function isValidLogsDatePreset(value: string | null | undefined): value is LogsDatePreset;
+export interface LogsDateRangeSelectorProps {
+    value: string;
+    onChange: (value: string) => void;
+}
+export declare function LogsDateRangeSelector({ value, onChange }: LogsDateRangeSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/domains/logs/components/logs-list.d.ts

@@ -0,0 +1,20 @@
+import { LogRecord } from '../types';
+export interface FeaturedIds {
+    logId?: string | null;
+    traceId?: string | null;
+    spanId?: string | null;
+}
+export interface LogsListProps {
+    logs: LogRecord[];
+    isLoading?: boolean;
+    isFetchingNextPage?: boolean;
+    hasNextPage?: boolean;
+    setEndOfListElement?: (element: HTMLDivElement | null) => void;
+    error?: Error | null;
+    hasActiveFilters?: boolean;
+    featuredLogId?: string | null;
+    featuredTraceId?: string | null;
+    featuredSpanId?: string | null;
+    onFeaturedChange?: (ids: FeaturedIds) => void;
+}
+export declare function LogsList({ logs, isLoading, isFetchingNextPage, hasNextPage, setEndOfListElement, error, hasActiveFilters, featuredLogId: controlledLogId, featuredTraceId: controlledTraceId, featuredSpanId: controlledSpanId, onFeaturedChange, }: LogsListProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/logs/components/logs-toolbar.d.ts

@@ -0,0 +1,17 @@
+import { FilterGroup, FilterColumn } from '../hooks/use-logs-filters';
+import { LogsDatePreset } from './logs-date-range-selector';
+export interface LogsToolbarProps {
+    onSearchChange: (query: string) => void;
+    datePreset: LogsDatePreset;
+    onDatePresetChange: (preset: LogsDatePreset) => void;
+    filterGroups: FilterGroup[];
+    filterColumns: FilterColumn[];
+    onToggleComparator: (id: string) => void;
+    onRemoveFilterGroup: (id: string) => void;
+    onClearAllFilters: () => void;
+    onFilterGroupsChange: (next: Record<string, string[]>) => void;
+    onReset?: () => void;
+    isLoading?: boolean;
+    hasActiveFilters?: boolean;
+}
+export declare function LogsToolbar({ onSearchChange, datePreset, onDatePresetChange, filterGroups, filterColumns, onToggleComparator: _onToggleComparator, onRemoveFilterGroup: _onRemoveFilterGroup, onClearAllFilters: _onClearAllFilters, onFilterGroupsChange, onReset, isLoading, hasActiveFilters, }: LogsToolbarProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/logs/components/no-logs-info.d.ts

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

package/dist/src/domains/logs/components/span-details.d.ts

@@ -0,0 +1,6 @@
+import { SpanRecord } from '@mastra/core/storage';
+export interface SpanDetailsProps {
+    span: SpanRecord;
+    onClose: () => void;
+}
+export declare function SpanDetails({ span, onClose }: SpanDetailsProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/logs/components/trace/format-hierarchical-spans.d.ts

@@ -0,0 +1,3 @@
+import { SpanRecord } from '@mastra/core/storage';
+import { UISpan } from './types';
+export declare const formatHierarchicalSpans: (spans: SpanRecord[]) => UISpan[];

package/dist/src/domains/logs/components/trace/format-logs-as-spans.d.ts

@@ -0,0 +1,10 @@
+import { LogRecord } from '../../types';
+import { UISpan } from './types';
+/**
+ * Converts LogRecord[] (filtered by traceId) into hierarchical UISpan[] for the timeline.
+ *
+ * Since LogRecord doesn't have the full span hierarchy (no parentSpanId, startedAt/endedAt pairs),
+ * we group logs by spanId and create a flat list of spans sorted by timestamp.
+ * Each unique spanId becomes a UISpan with its earliest and latest log timestamps as start/end.
+ */
+export declare function formatLogsAsSpans(logs: LogRecord[]): UISpan[];

package/dist/src/domains/logs/components/trace/get-descendant-ids.d.ts

@@ -0,0 +1,3 @@
+import { UISpan } from './types';
+export declare function getSpanDescendantIds(span: UISpan): string[];
+export declare function getAllSpanIds(spans: UISpan[]): string[];

package/dist/src/domains/logs/components/trace/shared.d.ts

@@ -0,0 +1,3 @@
+import { UISpanStyle } from './types';
+export declare const spanTypePrefixes: string[];
+export declare function getSpanTypeUi(type: string): UISpanStyle;

package/dist/src/domains/logs/components/trace/span-type-icon.d.ts

@@ -0,0 +1,6 @@
+type SpanTypeIconProps = {
+    icon: React.ReactNode;
+    color?: string;
+};
+export declare function SpanTypeIcon({ icon, color }: SpanTypeIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/domains/logs/components/trace/timeline-expand-col.d.ts

@@ -0,0 +1,13 @@
+type TimelineExpandColProps = {
+    isSelected?: boolean;
+    isFaded?: boolean;
+    isExpanded?: boolean;
+    toggleChildren?: () => void;
+    expandAllDescendants?: () => void;
+    expandedSpanIds?: string[];
+    totalDescendants?: number;
+    allDescendantsExpanded?: boolean;
+    numOfChildren?: number;
+};
+export declare function TimelineExpandCol({ isSelected, isFaded, isExpanded, toggleChildren, expandAllDescendants, totalDescendants, allDescendantsExpanded, numOfChildren, }: TimelineExpandColProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/domains/logs/components/trace/timeline-name-col.d.ts

@@ -0,0 +1,15 @@
+import { UISpan, UISpanStyle } from './types';
+type TimelineNameColProps = {
+    span: UISpan;
+    spanUI?: UISpanStyle | null;
+    isFaded?: boolean;
+    depth?: number;
+    onSpanClick?: (id: string) => void;
+    selectedSpanId?: string;
+    isLastChild?: boolean;
+    hasChildren?: boolean;
+    isRootSpan?: boolean;
+    isExpanded?: boolean;
+};
+export declare function TimelineNameCol({ span, spanUI: _spanUI, isFaded, depth, onSpanClick, selectedSpanId, isLastChild, hasChildren: _hasChildren, isRootSpan, isExpanded: _isExpanded, }: TimelineNameColProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/domains/logs/components/trace/timeline-structure-sign.d.ts

@@ -0,0 +1,5 @@
+type TimelineStructureSignProps = {
+    isLastChild?: boolean;
+};
+export declare function TimelineStructureSign({ isLastChild }: TimelineStructureSignProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/domains/logs/components/trace/timeline-timing-col.d.ts

@@ -0,0 +1,11 @@
+import { UISpan } from './types';
+type TimelineTimingColProps = {
+    span: UISpan;
+    selectedSpanId?: string;
+    isFaded?: boolean;
+    overallLatency?: number;
+    overallStartTime?: string;
+    color?: string;
+};
+export declare function TimelineTimingCol({ span, selectedSpanId, isFaded, overallLatency, overallStartTime, color, }: TimelineTimingColProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/domains/logs/components/trace/trace-timeline-span.d.ts

@@ -0,0 +1,17 @@
+import { UISpan } from './types';
+type TraceTimelineSpanProps = {
+    span: UISpan;
+    depth?: number;
+    onSpanClick?: (id: string) => void;
+    selectedSpanId?: string;
+    isLastChild?: boolean;
+    overallLatency?: number;
+    overallStartTime?: string;
+    fadedTypes?: string[];
+    searchPhrase?: string;
+    featuredSpanIds?: string[];
+    expandedSpanIds?: string[];
+    setExpandedSpanIds?: React.Dispatch<React.SetStateAction<string[]>>;
+};
+export declare function TraceTimelineSpan({ span, depth, onSpanClick, selectedSpanId, isLastChild, overallLatency, overallStartTime, fadedTypes, searchPhrase, featuredSpanIds, expandedSpanIds, setExpandedSpanIds, }: TraceTimelineSpanProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/domains/logs/components/trace/trace-timeline.d.ts

@@ -0,0 +1,13 @@
+import { UISpan } from './types';
+type TraceTimelineProps = {
+    hierarchicalSpans: UISpan[];
+    onSpanClick: (id: string) => void;
+    selectedSpanId?: string;
+    isLoading?: boolean;
+    fadedTypes?: string[];
+    expandedSpanIds?: string[];
+    setExpandedSpanIds?: React.Dispatch<React.SetStateAction<string[]>>;
+    featuredSpanIds?: string[];
+};
+export declare function TraceTimeline({ hierarchicalSpans, onSpanClick, selectedSpanId, isLoading, fadedTypes, expandedSpanIds, setExpandedSpanIds, featuredSpanIds, }: TraceTimelineProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/domains/logs/components/trace/types.d.ts

@@ -0,0 +1,17 @@
+export type UISpan = {
+    id: string;
+    name: string;
+    type: string;
+    latency: number;
+    startTime: string;
+    endTime?: string;
+    spans?: UISpan[];
+    parentSpanId?: string | null;
+};
+export type UISpanStyle = {
+    icon?: React.ReactNode;
+    color?: string;
+    label?: string;
+    bgColor?: string;
+    typePrefix: string;
+};

package/dist/src/domains/logs/components/trace-details.d.ts

@@ -0,0 +1,8 @@
+import { SpanRecord } from '@mastra/core/storage';
+export interface TraceDetailsProps {
+    traceId: string;
+    onClose: () => void;
+    onSpanSelect?: (span: SpanRecord | undefined) => void;
+    initialSpanId?: string | null;
+}
+export declare function TraceDetails({ traceId, onClose, onSpanSelect, initialSpanId }: TraceDetailsProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/domains/logs/hooks/use-logs-filters.d.ts

@@ -0,0 +1,25 @@
+import { LogRecord } from '../types';
+type Comparator = 'is' | 'is not';
+export type FilterGroup = {
+    id: string;
+    field: string;
+    comparator: Comparator;
+    values: string[];
+};
+export type FilterColumn = {
+    field: string;
+    plural: string;
+    values: string[];
+};
+export declare function useLogsFilters(logs: LogRecord[]): {
+    searchQuery: string;
+    setSearchQuery: import('../../../../node_modules/@types/react').Dispatch<import('../../../../node_modules/@types/react').SetStateAction<string>>;
+    filterGroups: FilterGroup[];
+    filterColumns: FilterColumn[];
+    toggleComparator: (id: string) => void;
+    removeFilterGroup: (id: string) => void;
+    clearAllFilters: () => void;
+    updateFilterGroups: (nextState: Record<string, string[]>) => void;
+    filteredLogs: LogRecord[];
+};
+export {};

package/dist/src/domains/logs/hooks/use-trace-spans.d.ts

@@ -0,0 +1,44 @@
+export declare function useTraceSpans(traceId: string | null | undefined): import('@tanstack/react-query').UseQueryResult<{
+    traceId: string;
+    spans: {
+        createdAt: Date;
+        updatedAt: Date | null;
+        name: string;
+        spanType: import('@mastra/core/observability').SpanType;
+        isEvent: boolean;
+        startedAt: Date;
+        traceId: string;
+        spanId: string;
+        experimentId?: string | null | undefined;
+        attributes?: Record<string, unknown> | null | undefined;
+        links?: unknown[] | null | undefined;
+        input?: unknown;
+        output?: unknown;
+        error?: unknown;
+        endedAt?: Date | null | undefined;
+        requestContext?: Record<string, unknown> | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+        tags?: string[] | null | undefined;
+        source?: string | null | undefined;
+        entityType?: import('@mastra/core/storage').EntityType | null | undefined;
+        entityId?: string | null | undefined;
+        entityName?: string | null | undefined;
+        parentEntityType?: import('@mastra/core/storage').EntityType | null | undefined;
+        parentEntityId?: string | null | undefined;
+        parentEntityName?: string | null | undefined;
+        rootEntityType?: import('@mastra/core/storage').EntityType | null | undefined;
+        rootEntityId?: string | null | undefined;
+        rootEntityName?: string | null | undefined;
+        userId?: string | null | undefined;
+        organizationId?: string | null | undefined;
+        resourceId?: string | null | undefined;
+        runId?: string | null | undefined;
+        sessionId?: string | null | undefined;
+        threadId?: string | null | undefined;
+        requestId?: string | null | undefined;
+        environment?: string | null | undefined;
+        serviceName?: string | null | undefined;
+        scope?: Record<string, unknown> | null | undefined;
+        parentSpanId?: string | null | undefined;
+    }[];
+}, Error>;

package/dist/src/domains/logs/index.d.ts

@@ -0,0 +1,7 @@
+export { LogDetails, type LogDetailsProps } from './components/log-details';
+export { TraceDetails, type TraceDetailsProps } from './components/trace-details';
+export { LogsList, type LogsListProps, type FeaturedIds } from './components/logs-list';
+export { LogsToolbar, type LogsToolbarProps } from './components/logs-toolbar';
+export { useLogsFilters, type FilterGroup, type FilterColumn } from './hooks/use-logs-filters';
+export { isValidLogsDatePreset, type LogsDatePreset } from './components/logs-date-range-selector';
+export type { LogRecord, LogLevel } from './types';

package/dist/src/domains/logs/types.d.ts

@@ -0,0 +1,32 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+export interface LogRecord {
+    timestamp: Date | string;
+    level: LogLevel;
+    message: string;
+    data?: Record<string, unknown> | null;
+    traceId?: string | null;
+    spanId?: string | null;
+    entityType?: string | null;
+    entityId?: string | null;
+    entityName?: string | null;
+    parentEntityType?: string | null;
+    parentEntityId?: string | null;
+    parentEntityName?: string | null;
+    rootEntityType?: string | null;
+    rootEntityId?: string | null;
+    rootEntityName?: string | null;
+    userId?: string | null;
+    organizationId?: string | null;
+    resourceId?: string | null;
+    runId?: string | null;
+    sessionId?: string | null;
+    threadId?: string | null;
+    requestId?: string | null;
+    environment?: string | null;
+    source?: string | null;
+    serviceName?: string | null;
+    scope?: string | null;
+    experimentId?: string | null;
+    tags?: string[] | null;
+    metadata?: Record<string, unknown> | null;
+}

package/dist/src/ds/components/DataDetailsPanel/data-details-panel-close-button.d.ts

@@ -0,0 +1,6 @@
+export interface DataDetailsPanelCloseButtonProps {
+    onClick: () => void;
+    tooltip?: string;
+    className?: string;
+}
+export declare function DataDetailsPanelCloseButton({ onClick, tooltip, className, }: DataDetailsPanelCloseButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataDetailsPanel/data-details-panel-code-section.d.ts

@@ -0,0 +1,8 @@
+export interface DataDetailsPanelCodeSectionProps {
+    title: React.ReactNode;
+    icon?: React.ReactNode;
+    codeStr?: string;
+    simplified?: boolean;
+    className?: string;
+}
+export declare function DataDetailsPanelCodeSection({ codeStr, title, icon, simplified, className, }: DataDetailsPanelCodeSectionProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/src/ds/components/DataDetailsPanel/data-details-panel-content.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from '../../../../node_modules/@types/react';
+export interface DataDetailsPanelContentProps {
+    children: ReactNode;
+}
+export declare function DataDetailsPanelContent({ children }: DataDetailsPanelContentProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataDetailsPanel/data-details-panel-header.d.ts

@@ -0,0 +1,5 @@
+export interface DataDetailsPanelHeaderProps {
+    className?: string;
+    children: React.ReactNode;
+}
+export declare function DataDetailsPanelHeader({ className, children }: DataDetailsPanelHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataDetailsPanel/data-details-panel-heading.d.ts

@@ -0,0 +1,5 @@
+export interface DataDetailsPanelHeadingProps {
+    className?: string;
+    children: React.ReactNode;
+}
+export declare function DataDetailsPanelHeading({ className, children }: DataDetailsPanelHeadingProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataDetailsPanel/data-details-panel-key-value-list.d.ts

@@ -0,0 +1,26 @@
+export interface DataDetailsPanelKeyValueListProps {
+    className?: string;
+    children: React.ReactNode;
+}
+declare function Root({ className, children }: DataDetailsPanelKeyValueListProps): import("react/jsx-runtime").JSX.Element;
+export interface DataDetailsPanelKeyValueListKeyProps {
+    className?: string;
+    children: React.ReactNode;
+}
+declare function Key({ className, children }: DataDetailsPanelKeyValueListKeyProps): import("react/jsx-runtime").JSX.Element;
+export interface DataDetailsPanelKeyValueListValueProps {
+    className?: string;
+    children: React.ReactNode;
+}
+declare function Value({ className, children }: DataDetailsPanelKeyValueListValueProps): import("react/jsx-runtime").JSX.Element;
+export interface DataDetailsPanelKeyValueListHeaderProps {
+    className?: string;
+    children: React.ReactNode;
+}
+declare function Header({ className, children }: DataDetailsPanelKeyValueListHeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare const DataDetailsPanelKeyValueList: typeof Root & {
+    Key: typeof Key;
+    Value: typeof Value;
+    Header: typeof Header;
+};
+export {};

package/dist/src/ds/components/DataDetailsPanel/data-details-panel-loading-data.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from '../../../../node_modules/@types/react';
+export interface DataDetailsPanelLoadingDataProps {
+    children?: ReactNode;
+}
+export declare function DataDetailsPanelLoadingData({ children }: DataDetailsPanelLoadingDataProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataDetailsPanel/data-details-panel-no-data.d.ts

@@ -0,0 +1,4 @@
+export interface DataDetailsPanelNoDataProps {
+    children?: React.ReactNode;
+}
+export declare function DataDetailsPanelNoData({ children }: DataDetailsPanelNoDataProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataDetailsPanel/data-details-panel.d.ts

@@ -0,0 +1,5 @@
+export interface DataDetailsPanelProps {
+    collapsed?: boolean;
+    children: React.ReactNode;
+}
+export declare function DataDetailsPanel({ collapsed, children }: DataDetailsPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataDetailsPanel/index.d.ts

@@ -0,0 +1,32 @@
+import { DataDetailsPanel as Root } from './data-details-panel';
+import { DataDetailsPanelCloseButton } from './data-details-panel-close-button';
+import { DataDetailsPanelCodeSection } from './data-details-panel-code-section';
+import { DataDetailsPanelContent } from './data-details-panel-content';
+import { DataDetailsPanelHeader } from './data-details-panel-header';
+import { DataDetailsPanelHeading } from './data-details-panel-heading';
+import { DataDetailsPanelLoadingData } from './data-details-panel-loading-data';
+import { DataDetailsPanelNoData } from './data-details-panel-no-data';
+declare const DataDetailsPanel: typeof Root & {
+    Header: typeof DataDetailsPanelHeader;
+    Heading: typeof DataDetailsPanelHeading;
+    CloseButton: typeof DataDetailsPanelCloseButton;
+    LoadingData: typeof DataDetailsPanelLoadingData;
+    NoData: typeof DataDetailsPanelNoData;
+    Content: typeof DataDetailsPanelContent;
+    KeyValueList: (({ className, children }: import('./data-details-panel-key-value-list').DataDetailsPanelKeyValueListProps) => import("react/jsx-runtime").JSX.Element) & {
+        Key: ({ className, children }: import('./data-details-panel-key-value-list').DataDetailsPanelKeyValueListKeyProps) => import("react/jsx-runtime").JSX.Element;
+        Value: ({ className, children }: import('./data-details-panel-key-value-list').DataDetailsPanelKeyValueListValueProps) => import("react/jsx-runtime").JSX.Element;
+        Header: ({ className, children }: import('./data-details-panel-key-value-list').DataDetailsPanelKeyValueListHeaderProps) => import("react/jsx-runtime").JSX.Element;
+    };
+    CodeSection: typeof DataDetailsPanelCodeSection;
+};
+export { DataDetailsPanel };
+export type { DataDetailsPanelProps } from './data-details-panel';
+export type { DataDetailsPanelHeaderProps } from './data-details-panel-header';
+export type { DataDetailsPanelHeadingProps } from './data-details-panel-heading';
+export type { DataDetailsPanelCloseButtonProps } from './data-details-panel-close-button';
+export type { DataDetailsPanelLoadingDataProps } from './data-details-panel-loading-data';
+export type { DataDetailsPanelNoDataProps } from './data-details-panel-no-data';
+export type { DataDetailsPanelContentProps } from './data-details-panel-content';
+export type { DataDetailsPanelKeyValueListProps, DataDetailsPanelKeyValueListKeyProps, DataDetailsPanelKeyValueListValueProps, DataDetailsPanelKeyValueListHeaderProps, } from './data-details-panel-key-value-list';
+export type { DataDetailsPanelCodeSectionProps } from './data-details-panel-code-section';

package/dist/src/ds/components/DataFilter/index.d.ts

@@ -0,0 +1,2 @@
+export { SelectDataFilter } from './select-data-filter';
+export type { SelectDataFilterCategory, SelectDataFilterMode, SelectDataFilterProps, SelectDataFilterState, SelectDataFilterValue, } from './select-data-filter';

package/dist/src/ds/components/DataFilter/select-data-filter.d.ts

@@ -0,0 +1,40 @@
+import { ReactNode } from '../../../../node_modules/@types/react';
+/** A single selectable value within a filter category */
+export type SelectDataFilterValue = {
+    value: string;
+    label: string;
+};
+/** Selection mode for a filter category */
+export type SelectDataFilterMode = 'single' | 'multi';
+/** A filter category that appears in the filter dropdown */
+export type SelectDataFilterCategory = {
+    /** Unique identifier */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Optional group header (categories with the same group are nested under it) */
+    group?: string;
+    /** Available values to pick from */
+    values: SelectDataFilterValue[];
+    /** 'single' = radio, 'multi' = checkboxes. Defaults to 'multi'. */
+    mode?: SelectDataFilterMode;
+};
+/** Current selected state: category id -> selected value(s) */
+export type SelectDataFilterState = Record<string, string[]>;
+export type SelectDataFilterProps = {
+    /** Filter categories to display */
+    categories: SelectDataFilterCategory[];
+    /** Current filter selections */
+    value: SelectDataFilterState;
+    /** Called when selections change */
+    onChange: (next: SelectDataFilterState) => void;
+    /** Disable the trigger button */
+    disabled?: boolean;
+    /** Override the trigger label */
+    label?: ReactNode;
+    /** Content alignment */
+    align?: 'start' | 'center' | 'end';
+    /** Minimum items before showing search in a submenu */
+    searchThreshold?: number;
+};
+export declare function SelectDataFilter({ categories, value, onChange, disabled, label, align, searchThreshold, }: SelectDataFilterProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataList/data-list-cells.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from '../../../../node_modules/@types/react';
+export type DataListCellProps = {
+    children: ReactNode;
+    className?: string;
+    height?: 'default' | 'compact';
+};
+export declare function DataListCell({ children, className, height }: DataListCellProps): import("react/jsx-runtime").JSX.Element;
+export declare function DataListTextCell({ children, className }: DataListCellProps): import("react/jsx-runtime").JSX.Element;
+export declare function DataListNameCell({ children, className }: DataListCellProps): import("react/jsx-runtime").JSX.Element;
+export declare function DataListDescriptionCell({ children, className }: DataListCellProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataList/data-list-next-page-loading.d.ts

@@ -0,0 +1,8 @@
+export type DataListNextPageLoadingProps = {
+    isLoading?: boolean;
+    hasMore?: boolean;
+    setEndOfListElement?: (element: HTMLDivElement | null) => void;
+    loadingText?: string;
+    noMoreDataText?: string;
+};
+export declare function DataListNextPageLoading({ isLoading, hasMore, setEndOfListElement, loadingText, noMoreDataText, }: DataListNextPageLoadingProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/src/ds/components/DataList/data-list-no-match.d.ts

@@ -0,0 +1,5 @@
+export type DataListNoMatchProps = {
+    message?: string;
+    className?: string;
+};
+export declare function DataListNoMatch({ message, className }: DataListNoMatchProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataList/data-list-root.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from '../../../../node_modules/@types/react';
+export type DataListRootProps = {
+    children: ReactNode;
+    columns: string;
+    className?: string;
+};
+export declare function DataListRoot({ children, columns, className }: DataListRootProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataList/data-list-row-button.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from '../../../../node_modules/@types/react';
+export type DataListRowButtonProps = {
+    children: ReactNode;
+    onClick?: () => void;
+    className?: string;
+};
+export declare function DataListRowButton({ children, onClick, className }: DataListRowButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataList/data-list-row-link.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from '../../../../node_modules/@types/react';
+export type DataListRowLinkProps = {
+    children: ReactNode;
+    to: string;
+    className?: string;
+};
+export declare function DataListRowLink({ children, to, className }: DataListRowLinkProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataList/data-list-row.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from '../../../../node_modules/@types/react';
+export type DataListRowProps = {
+    children: ReactNode;
+    className?: string;
+};
+export declare function DataListRow({ children, className }: DataListRowProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataList/data-list-skeleton.d.ts

@@ -0,0 +1,5 @@
+export type DataListSkeletonProps = {
+    columns?: string;
+    numberOfRows?: number;
+};
+export declare function DataListSkeleton({ columns, numberOfRows }: DataListSkeletonProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataList/data-list-top-cell.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from '../../../../node_modules/@types/react';
+export type DataListTopCellProps = {
+    children: ReactNode;
+    className?: string;
+};
+export declare const DataListTopCell: import('../../../../node_modules/@types/react').ForwardRefExoticComponent<DataListTopCellProps & import('../../../../node_modules/@types/react').RefAttributes<HTMLSpanElement>>;
+export type DataListTopCellWithTooltipProps = {
+    children: ReactNode;
+    tooltip: string;
+    className?: string;
+};
+export declare function DataListTopCellWithTooltip({ children, tooltip, className }: DataListTopCellWithTooltipProps): import("react/jsx-runtime").JSX.Element;
+export type DataListTopCellSmartProps = {
+    long: ReactNode;
+    short: ReactNode;
+    tooltip?: string;
+    breakpoint?: 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    className?: string;
+};
+export declare function DataListTopCellSmart({ long, short, tooltip, breakpoint, className, }: DataListTopCellSmartProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataList/data-list-top.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from '../../../../node_modules/@types/react';
+export type DataListTopProps = {
+    children: ReactNode;
+    className?: string;
+};
+export declare function DataListTop({ children, className }: DataListTopProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/ds/components/DataList/data-list.d.ts

@@ -0,0 +1,24 @@
+import { DataListCell, DataListTextCell, DataListNameCell, DataListDescriptionCell } from './data-list-cells';
+import { DataListNextPageLoading } from './data-list-next-page-loading';
+import { DataListNoMatch } from './data-list-no-match';
+import { DataListRoot } from './data-list-root';
+import { DataListRow } from './data-list-row';
+import { DataListRowButton } from './data-list-row-button';
+import { DataListRowLink } from './data-list-row-link';
+import { DataListTop } from './data-list-top';
+import { DataListTopCellWithTooltip, DataListTopCellSmart } from './data-list-top-cell';
+export declare const DataList: typeof DataListRoot & {
+    Top: typeof DataListTop;
+    TopCell: import('../../../../node_modules/@types/react').ForwardRefExoticComponent<import('./data-list-top-cell').DataListTopCellProps & import('../../../../node_modules/@types/react').RefAttributes<HTMLSpanElement>>;
+    TopCellWithTooltip: typeof DataListTopCellWithTooltip;
+    TopCellSmart: typeof DataListTopCellSmart;
+    Row: typeof DataListRow;
+    RowButton: typeof DataListRowButton;
+    RowLink: typeof DataListRowLink;
+    Cell: typeof DataListCell;
+    TextCell: typeof DataListTextCell;
+    NameCell: typeof DataListNameCell;
+    DescriptionCell: typeof DataListDescriptionCell;
+    NoMatch: typeof DataListNoMatch;
+    NextPageLoading: typeof DataListNextPageLoading;
+};