@emeryld/rrroutes-openapi 2.5.20 → 2.5.21

package/dist/web/v2/components/cache/CacheGroupModal.d.ts

@@ -0,0 +1,6 @@
+type CacheGroupModalProps = {
+    open: boolean;
+    groupId: string | null;
+};
+export default function CacheGroupModal({ open, groupId, }: CacheGroupModalProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/web/v2/components/cache/CacheGroupsSection.d.ts

@@ -0,0 +1 @@
+export default function CacheGroupsSection(): import("react/jsx-runtime").JSX.Element;

package/dist/web/v2/components/cache/CacheGroupsTable.d.ts

@@ -0,0 +1,7 @@
+import type { CacheGroupSummary } from './cacheUtils.js';
+type Props = {
+    groups: CacheGroupSummary[];
+    onGroupSelect: (groupId: string | null) => void;
+};
+export default function CacheGroupsTable({ groups, onGroupSelect }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/cache/CacheKeyDetailModal.d.ts

@@ -0,0 +1,6 @@
+type CacheKeyDetailModalProps = {
+    open: boolean;
+    cacheKey: string | null;
+};
+export default function CacheKeyDetailModal({ open, cacheKey, }: CacheKeyDetailModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/cache/CacheKeyTimelineChart.d.ts

@@ -0,0 +1,6 @@
+import type { CacheTraceType } from '../../types/types.cacheLog.js';
+type CacheKeyTimelineChartProps = {
+    traces: CacheTraceType[];
+};
+export default function CacheKeyTimelineChart({ traces, }: CacheKeyTimelineChartProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/cache/CacheKeysChart.d.ts

@@ -1,6 +1,6 @@
-import type { ChartData } from 'chart.js';
-import '../cache/cacheChartRegistry.js';
-export type CacheKeysChartProps = {
-    data: ChartData<'line'> | null;
+import type { CacheKeyTimelinePoint } from './cacheUtils.js';
+type CacheKeysChartProps = {
+    data: CacheKeyTimelinePoint[] | null;
 };
 export default function CacheKeysChart({ data }: CacheKeysChartProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/cache/CacheLink.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+type CacheLinkProps = {
+    children: ReactNode;
+    onClick: () => void;
+    color?: 'primary' | 'text.primary';
+};
+export default function CacheLink({ children, onClick, color, }: CacheLinkProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/cache/CacheTraceDetailModal.d.ts

@@ -0,0 +1,6 @@
+import type { CacheTraceType } from '../../types/types.cacheLog.js';
+type CacheTraceDetailModalProps = {
+    trace: CacheTraceType | null;
+};
+export default function CacheTraceDetailModal({ trace, }: CacheTraceDetailModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/cache/cacheInsightsUtils.d.ts

@@ -0,0 +1,54 @@
+import type { CacheLogType } from '../../types/types.cacheLog.js';
+import { type CacheGroupSummary } from './cacheUtils.js';
+import { type CacheEntryState } from './cacheStateUtils.js';
+export type HistogramBucket = {
+    label: string;
+    count: number;
+};
+export type CacheEntriesInsights = {
+    groupSummaries: CacheGroupSummary[];
+    totalKeys: number;
+    totalSize: number;
+    ttlCount: number;
+    ttlSum: number;
+    expiredKeys: number;
+    expiredSize: number;
+    stateCounts: Record<CacheEntryState, number>;
+    topGroupsByKeyCount: Array<{
+        label: string;
+        count: number;
+    }>;
+    topGroupsBySize: Array<{
+        label: string;
+        size: number;
+    }>;
+};
+export declare function buildCacheInsights(entries: CacheLogType[], now?: number): {
+    groupSummaries: {
+        groupId: string | null;
+        count: number;
+        lastSeen: number;
+        sampleKey: string | undefined;
+        totalSize: number;
+        avgTtl: number | undefined;
+        expiredCount: number;
+        expiredRatio: number;
+    }[];
+    totalKeys: number;
+    totalSize: number;
+    ttlCount: number;
+    ttlSum: number;
+    expiredKeys: number;
+    expiredSize: number;
+    stateCounts: Record<CacheEntryState, number>;
+    topGroupsByKeyCount: {
+        label: string;
+        count: number;
+    }[];
+    topGroupsBySize: {
+        label: string;
+        size: number;
+    }[];
+};
+export declare function buildTtlHistogram(entries: CacheLogType[]): HistogramBucket[];
+export declare function buildSizeHistogram(entries: CacheLogType[]): HistogramBucket[];

package/dist/web/v2/components/cache/cacheStateUtils.d.ts

@@ -0,0 +1,9 @@
+import type { CacheLogType } from '../../types/types.cacheLog.js';
+export type CacheEntryState = 'warm' | 'expired' | 'cold';
+type CacheEntryStateDetails = {
+    state: CacheEntryState;
+    expiresAt?: number;
+};
+export declare function getCacheEntryState(entry: Pick<CacheLogType, 'value' | 'ttlMs' | 'setAt' | 'updatedAt' | 'createdAt'>, now?: number): CacheEntryStateDetails;
+export declare function getCacheEntryStateLabel(state: CacheEntryState): "Cold" | "Expired" | "Warm";
+export {};

package/dist/web/v2/components/cache/cacheUtils.d.ts

@@ -1,10 +1,33 @@
-import type { ChartData } from 'chart.js';
-import { CacheOperation, type CacheLogType, type CacheTraceType } from '../../types/types.cacheLog.js';
 import { type SelectionState } from '../../types/filterTypes.js';
+import { CacheOperation, type CacheLogType, type CacheTraceType } from '../../types/types.cacheLog.js';
 export declare const CACHE_OPERATIONS: CacheOperation[];
 export type CacheOperationSelection = Record<CacheOperation, SelectionState>;
 export declare const DEFAULT_OPERATION_SELECTION: CacheOperationSelection;
 export declare function cycleSelectionState(prev: SelectionState): SelectionState;
 export declare function matchesOperationSelection(operation: CacheOperation | undefined, selection: CacheOperationSelection): boolean;
-export declare function buildCacheHitMissChartData(entries: CacheLogType[]): ChartData<'line'> | null;
-export declare function buildTraceTimelineChartData(traces: CacheTraceType[]): ChartData<'bar' | 'line'> | null;
+export type CacheKeyTimelinePoint = {
+    label: string;
+    timestamp: number;
+    count: number;
+};
+export declare function buildCacheHitMissChartData(entries: CacheLogType[]): CacheKeyTimelinePoint[] | null;
+export type CacheTraceTimelinePoint = {
+    label: string;
+    timestamp: number;
+    duration: number;
+    size: number;
+    operation: CacheOperation;
+    key?: string;
+};
+export declare function buildTraceTimelineChartData(traces: CacheTraceType[]): CacheTraceTimelinePoint[] | null;
+export declare function deriveCacheGroupId(key?: string | null): string | null;
+export type CacheGroupSummary = {
+    groupId: string | null;
+    count: number;
+    lastSeen: number;
+    sampleKey?: string;
+    totalSize?: number;
+    avgTtl?: number;
+    expiredCount?: number;
+    expiredRatio?: number;
+};

package/dist/web/v2/components/endpoints/EndpointDetailPanel.d.ts

@@ -1,8 +1,6 @@
-import { type EndpointTabKey } from '../../utils/endpoints.js';
 type EndpointDetailPanelProps = {
-    endpointId?: string | null;
-    activeTab?: EndpointTabKey;
-    onTabChange?: (tab: EndpointTabKey) => void;
+    endpointId?: string;
+    showHeader?: boolean;
 };
-export default function EndpointDetailPanel({ endpointId, activeTab, onTabChange, }: EndpointDetailPanelProps): import("react/jsx-runtime").JSX.Element;
+export default function EndpointDetailPanel({ endpointId, showHeader, }: EndpointDetailPanelProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/v2/components/feedback/EmptyState.d.ts

@@ -1,8 +1,7 @@
 import { ReactNode } from 'react';
-type EmptyStateProps = {
+export type EmptyStateProps = {
     title: string;
     description?: string;
     action?: ReactNode;
 };
 export default function EmptyState({ title, description, action, }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/web/v2/components/feedback/ErrorState.d.ts

@@ -1,7 +1,6 @@
-type ErrorStateProps = {
+export type ErrorStateProps = {
     message?: string;
     onRetry?: () => void;
     details?: string;
 };
 export default function ErrorState({ message, onRetry, details, }: ErrorStateProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/web/v2/components/feedback/LoadingState.d.ts

@@ -1,5 +1,4 @@
-type LoadingStateProps = {
+export type LoadingStateProps = {
     variant?: 'table' | 'inline' | 'full';
 };
 export default function LoadingState({ variant, }: LoadingStateProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/web/v2/components/feedback/StateHandler.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { EmptyStateProps } from './EmptyState';
+import { ErrorStateProps } from './ErrorState';
+import { LoadingStateProps } from './LoadingState';
+export type StateHandlerProps<T> = {
+    loading?: LoadingStateProps;
+    isLoading?: boolean;
+    error?: ErrorStateProps | null;
+    emptyFallback: EmptyStateProps;
+    data?: T;
+    children?: (data: T) => React.ReactNode;
+};
+export default function StateHandler<T>({ isLoading, loading, error, children, emptyFallback, data, }: StateHandlerProps<T>): string | number | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | null | undefined;

package/dist/web/v2/components/feeds/FeedPagination.d.ts

@@ -1,14 +1,12 @@
-import type { InfiniteData } from '@tanstack/react-query';
 import { ReactNode } from 'react';
+import { StateHandlerProps } from '../feedback/StateHandler';
 export type FeedPaginationProps<TItem> = {
-    data?: InfiniteData<any>;
     items?: TItem[];
-    fetchNextPage: () => Promise<unknown>;
+    fetchNextPage?: () => Promise<unknown>;
     hasNextPage?: boolean;
     isFetchingNextPage?: boolean;
     pageSize?: number;
-    isLoading: boolean;
-    extractItems?: (page: any) => TItem[];
     children: (items: TItem[]) => ReactNode;
+    stateHandler?: Omit<StateHandlerProps<TItem[]>, 'children' | 'data'>;
 };
-export default function FeedPagination<TItem>({ data, items: providedItems, fetchNextPage, hasNextPage, isFetchingNextPage, pageSize, isLoading, extractItems, children, }: FeedPaginationProps<TItem>): import("react/jsx-runtime").JSX.Element;
+export default function FeedPagination<TItem>({ items, fetchNextPage, hasNextPage, isFetchingNextPage, pageSize, children, stateHandler, }: FeedPaginationProps<TItem>): import("react/jsx-runtime").JSX.Element;

package/dist/web/v2/components/feeds/FeedSortableTable.d.ts

@@ -0,0 +1,30 @@
+import type { InfiniteData } from '@tanstack/react-query';
+import type { StateHandlerProps } from '../feedback/StateHandler.js';
+import { TableColumnDefinitions } from '../primitives/SortableTable.js';
+type SortQuery = {
+    orderBy?: string;
+    orderDirection?: 'asc' | 'desc';
+    pageSize?: number;
+};
+type EndpointPagination<TItem> = {
+    data?: InfiniteData<{
+        out?: TItem[];
+    }>;
+    fetchNextPage?: () => Promise<unknown>;
+    hasNextPage?: boolean;
+    isFetchingNextPage?: boolean;
+};
+export type FeedSortableTableProps<TItem extends Record<string, unknown>, Q extends SortQuery> = {
+    columns: TableColumnDefinitions<TItem>;
+    onRowClick?: (row: TItem, index: number) => void;
+    rowKey?: (row: TItem, index: number) => React.Key;
+    size?: 'small' | 'medium';
+    query: Q;
+    setQuery: (next: Q | ((prev: Q) => Q)) => void;
+    items?: TItem[];
+    endpoint?: EndpointPagination<TItem>;
+    reverse?: boolean;
+    stateHandler?: Omit<StateHandlerProps<TItem[]>, 'children' | 'data'>;
+};
+export default function FeedSortableTable<TItem extends Record<string, unknown>, Q extends SortQuery>({ columns, onRowClick, rowKey, size, query, setQuery, items: itemsProp, endpoint, reverse, stateHandler, }: FeedSortableTableProps<TItem, Q>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/feeds/tableColumns.d.ts

@@ -0,0 +1,12 @@
+import type { CacheLogType, CacheTraceType } from '../../types/types.cacheLog';
+import type { LogType } from '../../types/types.log';
+import type { RequestLogType } from '../../types/types.requestLog';
+import type { SocketEventType } from '../../types/types.socket';
+import type { CacheGroupSummary } from '../cache/cacheUtils';
+import type { TableColumnDefinitions } from '../primitives/SortableTable';
+export declare const requestLogTableColumns: TableColumnDefinitions<RequestLogType>;
+export declare const appLogTableColumns: TableColumnDefinitions<LogType>;
+export declare const socketEventTableColumns: TableColumnDefinitions<SocketEventType>;
+export declare const cacheLogTableColumns: TableColumnDefinitions<CacheLogType>;
+export declare const cacheTraceTableColumns: TableColumnDefinitions<CacheTraceType>;
+export declare const cacheGroupTableColumns: TableColumnDefinitions<CacheGroupSummary>;

package/dist/web/v2/components/filters/BaseFilterBar.d.ts

@@ -1,15 +1,15 @@
-import { type ReactNode, type RefObject } from 'react';
+import { SxProps } from '@mui/material/styles';
+import { type ReactNode } from 'react';
 import type { BaseFilter, FilterMode } from '../../types/filterTypes.js';
 type BaseFilterBarProps = {
     value: BaseFilter;
     onChange: (next: BaseFilter) => void;
-    children?: (mode: FilterMode) => ReactNode;
-    searchInputRef?: RefObject<HTMLInputElement>;
+    children?: (mode: FilterMode, nonExcludableVisual: SxProps | undefined) => ReactNode;
     tagOptions?: string[];
     groupOptions?: string[];
     onRefresh?: () => void;
     refreshing?: boolean;
     searchOnly?: boolean;
 };
-export default function BaseFilterBar({ value, onChange, children, searchInputRef, tagOptions, groupOptions, onRefresh, refreshing, searchOnly, }: BaseFilterBarProps): import("react/jsx-runtime").JSX.Element;
+export default function BaseFilterBar({ value, onChange, children, tagOptions, groupOptions, onRefresh, refreshing, searchOnly, }: BaseFilterBarProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/v2/components/filters/OptionPicker.d.ts

@@ -0,0 +1,9 @@
+type OptionPickerProps = {
+    options: string[];
+    selection: string[];
+    onChange: (next: string[]) => void;
+    label: string;
+    placeholder?: string;
+};
+declare function OptionPicker({ options, selection, onChange, placeholder, label, }: OptionPickerProps): import("react/jsx-runtime").JSX.Element;
+export default OptionPicker;

package/dist/web/v2/components/history/BucketRequestsModal.d.ts

@@ -0,0 +1,6 @@
+import type { BucketRequestsPayload } from '../../stores/modalStore.js';
+type BucketRequestsModalProps = {
+    bucket: BucketRequestsPayload | null;
+};
+export default function BucketRequestsModal({ bucket, }: BucketRequestsModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/history/RequestDetailContent.d.ts

@@ -1,13 +1,7 @@
-import type { CacheTraceType } from '../../types/types.cacheLog.js';
-import type { LogType } from '../../types/types.log.js';
 import type { RequestLogType } from '../../types/types.requestLog.js';
-import type { SocketEventType } from '../../types/types.socket.js';
 type RequestDetailContentProps = {
     request: RequestLogType;
-    caches?: CacheTraceType[];
-    logs?: LogType[];
-    sockets?: SocketEventType[];
     onReplay?: (request: RequestLogType) => void;
 };
-export default function RequestDetailContent({ request, caches, logs, sockets, onReplay, }: RequestDetailContentProps): import("react/jsx-runtime").JSX.Element;
+export default function RequestDetailContent({ request, onReplay, }: RequestDetailContentProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/v2/components/history/RequestDetailModal.d.ts

@@ -1,12 +1,8 @@
 import type { RequestLogType } from '../../types/types.requestLog.js';
 type RequestDetailModalProps = {
     open: boolean;
-    request: RequestLogType | null;
-    requestId?: string | null;
-    onClose: () => void;
+    requestId?: string;
     onReplay?: (request: RequestLogType) => void;
-    onPrev?: () => void;
-    onNext?: () => void;
 };
-export default function RequestDetailModal({ open, request, requestId, onClose, onReplay, onPrev, onNext, }: RequestDetailModalProps): import("react/jsx-runtime").JSX.Element;
+export default function RequestDetailModal({ open, requestId, onReplay, }: RequestDetailModalProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/v2/components/layout/CardSection.d.ts

@@ -2,8 +2,9 @@ import { ReactNode } from 'react';
 type CardSectionProps = {
     title?: string;
     actions?: ReactNode;
-    children: ReactNode;
+    children?: ReactNode;
     flex?: number;
+    bgcolor?: string;
 };
-export default function CardSection({ title, actions, children, flex, }: CardSectionProps): import("react/jsx-runtime").JSX.Element;
+export default function CardSection({ title, actions, children, flex, bgcolor, }: CardSectionProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/v2/components/layout/TabbedPage.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+type TabbedPageProps<T extends string> = {
+    tabs: Record<T, React.ReactNode>;
+    initialTab: NoInfer<T>;
+    onTabChange?: (tab: T) => void;
+};
+declare function TabbedPage<T extends string>({ initialTab, tabs, onTabChange, }: TabbedPageProps<T>): import("react/jsx-runtime").JSX.Element;
+export default TabbedPage;

package/dist/web/v2/components/logs/LogGroupDetailModal.d.ts

@@ -1,13 +1,10 @@
 import type { LogType } from '../../types/types.log.js';
 type LogGroupDetailModalProps = {
     open: boolean;
-    groupId?: string | null;
+    groupId?: string;
     baseQuery: Record<string, unknown>;
-    triggerLog?: LogType | null;
-    onClose: () => void;
-    onPrev?: () => void;
-    onNext?: () => void;
+    triggerLog?: LogType;
 };
-export default function LogGroupDetailModal({ open, groupId, baseQuery, triggerLog, onClose, onPrev, onNext, }: LogGroupDetailModalProps): import("react/jsx-runtime").JSX.Element;
+export default function LogGroupDetailModal({ open, groupId, baseQuery, triggerLog, }: LogGroupDetailModalProps): import("react/jsx-runtime").JSX.Element;
 export declare function renderMessage(log: LogType): string;
 export {};

package/dist/web/v2/components/primitives/SortableTable.d.ts

@@ -1,29 +1,23 @@
-import type { ReactNode } from 'react';
 import type { TableCellProps } from '@mui/material';
 export type SortDirection = 'asc' | 'desc' | 'none';
-type ColumnDefinition = {
-    key: string;
+export type TableColumnDefinition<T extends Record<string, unknown>, K extends keyof T & string> = {
+    key: K;
     label?: string;
     align?: TableCellProps['align'];
-    width?: number | string;
+    width?: number;
+    render?: (value: T[K], entry: T) => React.ReactNode;
 };
-export type RawColumnDefinition = string | ColumnDefinition;
-type RowRendererParams<T> = {
-    row: T;
-    rowIndex: number;
-    cells: ReactNode[];
-};
-type SortableTableProps<T extends Record<string, unknown>> = {
-    data: T[];
-    columns: RawColumnDefinition[];
-    sortBy?: string | null;
+export type TableColumnDefinitions<T extends Record<string, unknown>> = Partial<{
+    [K in keyof T & string]: TableColumnDefinition<T, K>;
+}>;
+export type SortableTableProps<T extends Record<string, unknown>> = {
+    items: T[];
+    columns: TableColumnDefinitions<T>;
+    sortBy?: string | undefined;
     sortDirection?: SortDirection;
-    onSortChange?: (newSortBy: string | null, newSortDirection: SortDirection) => void;
-    renderCell?: (row: T, columnKey: string) => ReactNode;
+    onSortChange?: (newSortBy: string | undefined, newSortDirection: SortDirection) => void;
     rowKey?: (row: T, index: number) => React.Key;
+    onRowClick?: (row: T, index: number) => void;
     size?: 'small' | 'medium';
-    stickyHeader?: boolean;
-    rowRenderer?: (params: RowRendererParams<T>) => ReactNode;
 };
-export default function SortableTable<T extends Record<string, unknown>>({ data, columns, sortBy, sortDirection, onSortChange, renderCell, rowRenderer, rowKey, size, stickyHeader, }: SortableTableProps<T>): import("react/jsx-runtime").JSX.Element;
-export {};
+export default function SortableTable<T extends Record<string, unknown>>({ items, columns, sortBy, sortDirection, onSortChange, onRowClick, rowKey, size, }: SortableTableProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/web/v2/components/primitives/TableCells.d.ts

@@ -0,0 +1,10 @@
+import type { TypographyProps } from '@mui/material';
+import type { ReactNode } from 'react';
+type MonospaceCellProps = {
+    children: ReactNode;
+    color?: TypographyProps['color'];
+    noWrap?: boolean;
+    sx?: TypographyProps['sx'];
+};
+export declare function MonospaceCell({ children, color, noWrap, sx, }: MonospaceCellProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/registries/RegistryListEditor.d.ts

@@ -0,0 +1,21 @@
+import type { Registry } from '../../registries/genericRegistry.js';
+export type ParseResult<T> = {
+    value: T;
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: string;
+};
+type RegistryListEditorProps<T> = {
+    registry: Registry<T[]>;
+    formatItem: (item: T) => string;
+    parseItem: (raw: string) => ParseResult<T>;
+    description?: string;
+    itemPlaceholder?: string;
+    addLabel?: string;
+    addPlaceholder?: string;
+    emptyMessage?: string;
+    getItemKey?: (item: T, index: number) => string;
+};
+export default function RegistryListEditor<T>({ registry, formatItem, parseItem, description, itemPlaceholder, addLabel, addPlaceholder, emptyMessage, getItemKey, }: RegistryListEditorProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/requests/timeline/RequestTimeline.d.ts

@@ -1,13 +1,5 @@
-import type { CacheTraceType } from '../../../types/types.cacheLog.js';
-import type { LogType } from '../../../types/types.log.js';
-import type { SocketEventType } from '../../../types/types.socket.js';
-import type { RequestTimelineEvent } from './types.js';
 type RequestTimelineProps = {
-    events: RequestTimelineEvent[];
-    onSelectCache?: (cache: CacheTraceType) => void;
-    onSelectLog?: (log: LogType) => void;
-    onSelectSocket?: (socket: SocketEventType) => void;
-    onSelectCacheKey?: (key: string) => void;
+    requestId: string;
 };
-export default function RequestTimeline({ events, onSelectCache, onSelectLog, onSelectSocket, onSelectCacheKey, }: RequestTimelineProps): import("react/jsx-runtime").JSX.Element;
+export default function RequestTimeline({ requestId }: RequestTimelineProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/v2/components/requests/timeline/RequestTimelineFilters.d.ts

@@ -2,19 +2,25 @@ import type { RequestTimelineEvent } from './types.js';
 export type TimelineFilterState = {
     kinds: Set<RequestTimelineEvent['kind']>;
     logLevels: Set<string>;
-    cacheTypes: Set<string>;
+    cacheOperations: Set<string>;
     socketDirections: Set<string>;
 };
 export type TimelineFilterOptions = {
     kinds: RequestTimelineEvent['kind'][];
     logLevels: string[];
-    cacheTypes: string[];
+    cacheOperations: string[];
     socketDirections: string[];
 };
+export type TimelineFilterStats = {
+    logLevelCounts: Record<string, number>;
+    cacheOperationCounts: Record<string, number>;
+    socketDirectionCounts: Record<string, number>;
+};
 type RequestTimelineFiltersProps = {
     available: TimelineFilterOptions;
     value: TimelineFilterState;
     onChange: (next: TimelineFilterState) => void;
+    stats: TimelineFilterStats;
 };
-export default function RequestTimelineFilters({ available, value, onChange, }: RequestTimelineFiltersProps): import("react/jsx-runtime").JSX.Element | null;
+export default function RequestTimelineFilters({ available, value, onChange, stats, }: RequestTimelineFiltersProps): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/web/v2/components/requests/timeline/RequestTimelineRow.d.ts

@@ -1,15 +1,8 @@
-import type { CacheTraceType } from '../../../types/types.cacheLog.js';
-import type { LogType } from '../../../types/types.log.js';
-import type { SocketEventType } from '../../../types/types.socket.js';
 import type { RequestTimelineEvent } from './types.js';
 type RequestTimelineRowProps = {
     event: RequestTimelineEvent;
     deltaMs: number | null;
     maxDeltaMs: number;
-    onSelectCache?: (cache: CacheTraceType) => void;
-    onSelectLog?: (log: LogType) => void;
-    onSelectSocket?: (socket: SocketEventType) => void;
-    onSelectCacheKey?: (key: string) => void;
 };
-export default function RequestTimelineRow({ event, deltaMs, maxDeltaMs, onSelectCache, onSelectLog, onSelectSocket, onSelectCacheKey, }: RequestTimelineRowProps): import("react/jsx-runtime").JSX.Element;
+export default function RequestTimelineRow({ event, deltaMs, maxDeltaMs, }: RequestTimelineRowProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/v2/components/schema/SchemaTreeView.d.ts

@@ -3,5 +3,5 @@ type SchemaTreeViewProps = {
     schema?: SerializableSchema;
     title?: string;
 };
-export default function SchemaTreeView({ schema, title, }: SchemaTreeViewProps): import("react/jsx-runtime").JSX.Element;
+export default function SchemaTreeView({ schema, title }: SchemaTreeViewProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/v2/components/sockets/SocketEventDetailModal.d.ts

@@ -1,9 +1,6 @@
 import type { SocketEventType } from '../../types/types.socket.js';
 type SocketEventDetailModalProps = {
-    open: boolean;
     event: SocketEventType | null;
-    onClose: () => void;
-    onOpenGroup?: (groupId: string) => void;
 };
-export default function SocketEventDetailModal({ open, event, onClose, onOpenGroup, }: SocketEventDetailModalProps): import("react/jsx-runtime").JSX.Element;
+export default function SocketEventDetailModal({ event, }: SocketEventDetailModalProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/v2/components/stats/ChartRow.d.ts

@@ -0,0 +1,12 @@
+type ChartProps = {
+    title: string;
+    subText?: string;
+    chart: React.ReactNode;
+    actions?: React.ReactNode;
+};
+type ChartRowProps = {
+    charts: ChartProps[];
+    height?: number;
+};
+export declare function ChartRow({ charts, height }: ChartRowProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/stats/SummaryStats.d.ts

@@ -0,0 +1,10 @@
+export type Stat = {
+    label: string;
+    value: string | number;
+    detail?: string;
+};
+type SummaryStatsProps = {
+    stats: Stat[];
+};
+export declare const SummaryStats: ({ stats }: SummaryStatsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/tags/CacheStateChip.d.ts

@@ -0,0 +1,7 @@
+import type { ChipProps } from '@mui/material';
+import type { CacheEntryState } from '../../components/cache/cacheStateUtils.js';
+type CacheStateChipProps = {
+    state: CacheEntryState;
+} & Omit<ChipProps, 'label'>;
+export default function CacheStateChip({ state, sx, ...rest }: CacheStateChipProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/tags/LogLevelChip.d.ts

@@ -1,9 +1,10 @@
 import { ChipSelectionState } from './chip.types';
 type LogLevelChipProps = {
     level: string;
+    color?: string;
     state?: ChipSelectionState;
     selected?: boolean;
     onClick?: () => void;
 };
-export default function LogLevelChip({ level, state, selected, onClick, }: LogLevelChipProps): import("react/jsx-runtime").JSX.Element;
+export default function LogLevelChip({ level, color, state, selected, onClick, }: LogLevelChipProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/v2/hooks/useInfiniteItems.d.ts

@@ -0,0 +1,16 @@
+import type { InfiniteData } from '@tanstack/react-query';
+import { ErrorStateProps } from '../components/feedback/ErrorState';
+export type UseInfiniteItemsOptions<TPage extends {
+    out?: any[];
+}> = {
+    reverse?: boolean;
+    fallback?: TPage['out'];
+};
+export declare function useInfiniteItems<TPage extends {
+    out?: any[];
+}>(data?: InfiniteData<TPage>, options?: UseInfiniteItemsOptions<TPage>): TPage['out'];
+export declare function useExportRows<T, R>(items: T[], getRow: (item: T) => R): R[];
+export declare function useErrorMessage(error: unknown, args: {
+    messageFallback: string;
+    refetch: () => void;
+}): ErrorStateProps | null;