@emeryld/rrroutes-openapi 2.5.7 → 2.5.10

package/dist/web/v2/components/performance/PerformanceMonitor.d.ts

@@ -0,0 +1,207 @@
+export declare function PerformanceMonitor(): null;
+/**
+ * You are a senior performance engineer with full read/write access to my TypeScript React web app codebase. The openapi package uses TanStack Query (React Query). Your job is to identify why the UI feels slow and “blocked” (initial render appears to wait for data), and why navigation gets slower as I move through screens, then implement fixes that materially improve perceived and actual performance.
+
+Goals (in order)
+
+Make initial render and route transitions feel instant (render shells immediately, avoid blocking on data).
+
+Reduce unnecessary re-renders and expensive renders (especially list/detail screens).
+
+Prevent navigation slowdown over time (memory leaks, query/cache growth, event listeners, suspense waterfalls, etc.).
+
+Provide measurable before/after evidence (profiling + metrics).
+
+Deliverables
+
+A concise root-cause report with:
+
+Top 5 bottlenecks (what, where, why it happens)
+
+Evidence (profiling screenshots/notes, flamegraphs, React Profiler findings, network waterfalls, query counts)
+
+Fixes applied (files changed, reasoning, expected impact)
+
+A PR-style set of code changes that:
+
+Removes UI blocking on data (show immediate skeletons/placeholders, avoid “all-or-nothing” rendering)
+
+Improves navigation performance and prevents degradation over time
+
+Adds lightweight instrumentation so regressions are caught
+
+A “Performance Playbook” markdown doc added to the repo with guidelines specific to this app.
+
+Step-by-step tasks
+1) Establish a baseline (must be reproducible)
+
+Add minimal instrumentation (do not over-instrument):
+
+Log route transition timings (start/end, route name).
+
+Log React Query activity per route: active queries count, fetch durations, cache size growth.
+
+Run the app locally and capture:
+
+React DevTools Profiler traces for: initial load, navigating between 3–5 common routes, repeating navigation loop (A→B→C→A…).
+
+Chrome Performance recording for the same flows.
+
+Network tab waterfall (note slow endpoints and waterfalls).
+
+Summarize baseline metrics:
+
+Time to first meaningful paint (approx).
+
+Route transition time distribution (p50/p95).
+
+Long tasks (>50ms) frequency during navigation.
+
+2) Find the “render waits for data” causes
+
+Search for patterns that block rendering:
+
+Suspense usage with query fetching (Query + Suspense) causing full-page suspension/waterfalls.
+
+Route-level loaders gating navigation until queries resolve.
+
+Conditional rendering like if (isLoading) return null or returning heavy spinners that block layout.
+
+Over-fetching on route mount (many queries start at once; dependent query chains).
+
+Query keys that change frequently (causing refetch storms).
+
+enabled flags misused (queries refetch repeatedly).
+
+staleTime/cacheTime/gcTime defaults causing too much refetching.
+
+Implement fixes to ensure:
+
+Layout renders immediately with stable structure.
+
+Data regions render progressively (skeletons, placeholders, optimistic UI).
+
+Avoid suspense waterfalls: co-locate suspense boundaries narrowly, or disable suspense where it blocks whole screens.
+
+Use placeholderData / keepPreviousData appropriately for list-to-detail and pagination.
+
+Prefetch on hover/intent and on route transitions where appropriate.
+
+3) Identify why navigation gets slower over time
+
+Look for:
+
+Memory leaks (event listeners, timers, subscriptions not cleaned up).
+
+React Query cache growth (unbounded query keys, not garbage collecting, huge cached payloads).
+
+Components that accumulate state or keep large objects in memory.
+
+Re-renders increasing with each navigation (global stores, context providers re-creating values, selectors missing).
+
+Layout components that re-mount unnecessarily on navigation.
+
+Heavy computations on render (sorting/filtering/formatting done inline).
+
+Large lists without virtualization.
+
+Images/fonts causing layout shifts or repeated decoding.
+
+Confirm with evidence:
+
+Heap snapshots before/after repeated navigation loop.
+
+Count of mounted components and listeners over time.
+
+Query cache size trend over time.
+
+Fixes may include:
+
+Stabilize query keys; remove key explosions.
+
+Set sensible staleTime and gcTime (TanStack Query v5) or cacheTime (v4) for heavy data.
+
+Use select in queries to reduce data shape and rerender impact.
+
+Split providers; memoize context values; use useMemo/useCallback where it materially reduces renders.
+
+Add list virtualization (e.g. react-virtual) for long lists.
+
+Defer expensive work with useDeferredValue, startTransition, or moving work off render.
+
+Ensure route-level code splitting and avoid importing heavy modules eagerly.
+
+4) Reduce avoidable re-renders (systematically)
+
+Use React Profiler to find top rendering components per route.
+
+For each hotspot:
+
+Explain what triggers re-render.
+
+Apply the least invasive fix: memoization, stable props, selectors, splitting components, moving derived data into useMemo, etc.
+
+Verify improvements with updated profiler traces.
+
+5) React Query-specific audit (must do)
+
+Review QueryClient configuration:
+
+retries, refetchOnWindowFocus, refetchOnMount, staleTime/gcTime defaults, structuralSharing, notifyOnChangeProps.
+
+Identify queries that:
+
+Refetch too often.
+
+Fetch too much data.
+
+Cause render cascades (many subscribers).
+
+Apply improvements:
+
+Set global defaults + per-query overrides.
+
+Use prefetchQuery strategically.
+
+Use keepPreviousData for pagination and route param changes.
+
+Use placeholderData to keep UI stable.
+
+Use select to minimize component updates.
+
+Consider useInfiniteQuery where appropriate.
+
+6) Add guardrails
+
+Add a small /docs/performance.md with:
+
+Patterns to avoid (route-level suspense, key explosions, inline heavy work).
+
+Standard query defaults and when to override.
+
+How to profile this app (exact steps).
+
+Add a simple CI/lint-style check if feasible (optional) to catch egregious patterns (like return null on isLoading in pages).
+
+Constraints
+
+Do not change product behavior or UX beyond making loading states progressive and navigation snappier.
+
+Avoid large rewrites unless absolutely necessary.
+
+Prefer targeted, well-justified changes with measurable impact.
+
+Keep code idiomatic TypeScript/React and consistent with existing patterns.
+
+Output format
+
+“Findings” (ranked list with evidence)
+
+“Fixes implemented” (bullets + file paths)
+
+“Metrics before/after”
+
+“Follow-ups” (optional, highest ROI next steps)
+
+Start by scanning the codebase for route-level rendering gates and Suspense usage, then profile to confirm, then implement improvements.
+ */

package/dist/web/v2/components/presets/PresetForm.d.ts

@@ -2,6 +2,7 @@ import type { PresetType } from '../../types/types.preset.js';
 type PresetFormProps = {
     value: PresetType;
     onChange: (next: PresetType) => void;
+    disabled?: boolean;
 };
-export default function PresetForm({ value, onChange }: PresetFormProps): import("react/jsx-runtime").JSX.Element;
+export default function PresetForm({ value, onChange, disabled }: PresetFormProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/web/v2/components/presets/PresetOperationsTabsEditor.d.ts

@@ -0,0 +1,17 @@
+import type { PresetType } from '../../types/types.preset.js';
+type PresetOperationsTabsEditorProps = {
+    operations: PresetType['operations'];
+    onChange: (operations: PresetType['operations']) => void;
+    disabled?: boolean;
+    onRunAllStateChange?: (running: boolean) => void;
+};
+export type PresetOperationsTabsEditorHandle = {
+    runAll: () => Promise<void>;
+    isRunningAll: boolean;
+    commitPendingEdits: () => {
+        ok: boolean;
+        operations: PresetType['operations'];
+    };
+};
+declare const PresetOperationsTabsEditor: import("react").ForwardRefExoticComponent<PresetOperationsTabsEditorProps & import("react").RefAttributes<PresetOperationsTabsEditorHandle>>;
+export default PresetOperationsTabsEditor;

package/dist/web/v2/components/presets/PresetsCsvActions.d.ts

@@ -0,0 +1,7 @@
+import type { PresetType } from '../../types/types.preset.js';
+type PresetsCsvActionsProps = {
+    presets: PresetType[];
+    onImportComplete?: () => void;
+};
+export default function PresetsCsvActions({ presets, onImportComplete, }: PresetsCsvActionsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/presets/presetOperationAdapters.d.ts

@@ -0,0 +1,11 @@
+import type { PlaygroundInputs } from '../../stores/clientStore.js';
+import type { KeyValueRow } from '../../types/types.kvRow.js';
+import type { PresetType } from '../../types/types.preset.js';
+export type PresetOperationEditorModel = {
+    queryRows: KeyValueRow[];
+    headerRows: KeyValueRow[];
+    bodyText: string;
+};
+export declare function mapOperationToEditorModel(operation: PresetType['operations'][number]): PresetOperationEditorModel;
+export declare function mapEditorModelToOperation(operation: PresetType['operations'][number], model: PresetOperationEditorModel): PresetType['operations'][number];
+export declare function buildPresetInputs(operation: PresetType['operations'][number]): PlaygroundInputs;

package/dist/web/v2/components/presets/presetOperationRun.d.ts

@@ -0,0 +1,35 @@
+import type { PresetType } from '../../types/types.preset.js';
+export type OperationRunState = {
+    status: 'idle' | 'running' | 'success' | 'error';
+    statusCode?: number;
+    durationMs?: number;
+    errorMessage?: string;
+    response?: unknown;
+    createdAt?: number;
+};
+export type PresetOperationRunResult = {
+    success: boolean;
+    state: OperationRunState;
+};
+export declare function usePresetOperationRunner(): (operation: PresetType["operations"][number]) => Promise<{
+    success: boolean;
+    state: {
+        status: "success" | "error";
+        statusCode: number;
+        durationMs: number;
+        errorMessage: string | undefined;
+        response: any;
+        createdAt: number;
+    };
+} | {
+    success: boolean;
+    state: {
+        status: "error";
+        errorMessage: string;
+        createdAt: number;
+        statusCode?: undefined;
+        durationMs?: undefined;
+        response?: undefined;
+    };
+}>;
+export declare function shouldConfirmOperation(operation: PresetType['operations'][number]): boolean;

package/dist/web/v2/components/presets/presetOperationUtils.d.ts

@@ -0,0 +1,2 @@
+import type { PresetType } from '../../types/types.preset.js';
+export declare function createPresetOperation(overrides?: Partial<PresetType['operations'][number]>): PresetType['operations'][number];

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

@@ -0,0 +1,6 @@
+import { type TableRowProps } from '@mui/material';
+type HoverRowProps = TableRowProps & {
+    clickable?: boolean;
+};
+export default function HoverRow({ clickable, sx, ...rest }: HoverRowProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,7 @@
+import { type ButtonBaseProps } from '@mui/material/ButtonBase';
+import type { ReactNode } from 'react';
+type InlineActionButtonProps = Omit<ButtonBaseProps, 'children'> & {
+    children: ReactNode;
+};
+export default function InlineActionButton({ children, sx, type, ...rest }: InlineActionButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,8 @@
+import { type ButtonBaseProps } from '@mui/material/ButtonBase';
+import { type ReactNode } from 'react';
+type SurfaceActionAreaProps = ButtonBaseProps & {
+    children: ReactNode;
+    active?: boolean;
+};
+declare const _default: import("react").ForwardRefExoticComponent<Omit<SurfaceActionAreaProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export default _default;

package/dist/web/v2/components/request/LastRunPanel.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+export type LastRunMeta = {
+    status: number;
+    duration?: number;
+    time: string;
+    errorMessage?: string;
+    response?: unknown;
+};
+type LastRunPanelProps = {
+    title?: string;
+    lastRun?: LastRunMeta | null;
+    runButton: ReactNode;
+    extendable?: boolean;
+    maxDetailsHeight?: number;
+};
+export default function LastRunPanel({ title, lastRun, runButton, extendable, maxDetailsHeight, }: LastRunPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/request/RequestInputsEditor.d.ts

@@ -0,0 +1,38 @@
+import { ReactNode } from 'react';
+import { type MethodType } from '../../types/types.base.js';
+import type { KeyValueRow } from '../../types/types.kvRow.js';
+type SectionConfig = {
+    defaultExpanded?: boolean;
+    summaryActions?: ReactNode;
+    schemaView?: ReactNode;
+};
+type QuerySectionConfig = SectionConfig & {
+    showFieldMeta?: boolean;
+};
+type HeadersSectionConfig = SectionConfig & {
+    actions?: ReactNode;
+};
+type BodySectionConfig = SectionConfig & {
+    helperText?: string;
+    error?: boolean;
+    onBlur?: () => void;
+};
+type RequestInputsEditorProps = {
+    method: MethodType;
+    path: string;
+    queryRows: KeyValueRow[];
+    headerRows: KeyValueRow[];
+    bodyText: string;
+    onMethodChange: (method: MethodType) => void;
+    onPathChange: (path: string) => void;
+    onQueryChange: (rows: KeyValueRow[]) => void;
+    onHeadersChange: (rows: KeyValueRow[]) => void;
+    onBodyChange: (value: string) => void;
+    onBodyBlur?: () => void;
+    querySection?: QuerySectionConfig;
+    headersSection?: HeadersSectionConfig;
+    bodySection?: BodySectionConfig;
+    disabled?: boolean;
+};
+export default function RequestInputsEditor({ method, path, queryRows, headerRows, bodyText, onMethodChange, onPathChange, onQueryChange, onHeadersChange, onBodyChange, querySection, headersSection, bodySection, disabled, }: RequestInputsEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/web/v2/components/request/RequestUrlSelector.d.ts

@@ -0,0 +1,15 @@
+import type { EndpointOption } from '../../utils/endpoints.js';
+type RequestUrlSelectorProps = {
+    requestInput: string;
+    endpointOptions: EndpointOption[];
+    isLoading: boolean;
+    onEndpointSelect: (_: unknown, value: EndpointOption | string | null) => void;
+    onRequestInputChange: (_: unknown, value: string, reason: string) => void;
+    onCommit?: () => void;
+    onBlur?: () => void;
+    label?: string;
+    helperText?: string;
+    disabled?: boolean;
+};
+export default function RequestUrlSelector({ requestInput, endpointOptions, isLoading, onEndpointSelect, onRequestInputChange, onCommit, onBlur, label, helperText, disabled, }: RequestUrlSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,13 @@
+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;
+};
+export default function RequestTimeline({ events, onSelectCache, onSelectLog, onSelectSocket, onSelectCacheKey, }: RequestTimelineProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,13 @@
+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 MiniCardProps = {
+    event: RequestTimelineEvent;
+    onSelectCache?: (cache: CacheTraceType) => void;
+    onSelectLog?: (log: LogType) => void;
+    onSelectSocket?: (socket: SocketEventType) => void;
+    onSelectCacheKey?: (key: string) => void;
+};
+export default function RequestTimelineEventMiniCard({ event, onSelectCache, onSelectLog, onSelectSocket, onSelectCacheKey, }: MiniCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,20 @@
+import type { RequestTimelineEvent } from './types.js';
+export type TimelineFilterState = {
+    kinds: Set<RequestTimelineEvent['kind']>;
+    logLevels: Set<string>;
+    cacheTypes: Set<string>;
+    socketDirections: Set<string>;
+};
+export type TimelineFilterOptions = {
+    kinds: RequestTimelineEvent['kind'][];
+    logLevels: string[];
+    cacheTypes: string[];
+    socketDirections: string[];
+};
+type RequestTimelineFiltersProps = {
+    available: TimelineFilterOptions;
+    value: TimelineFilterState;
+    onChange: (next: TimelineFilterState) => void;
+};
+export default function RequestTimelineFilters({ available, value, onChange, }: RequestTimelineFiltersProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -0,0 +1,15 @@
+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 {};

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

@@ -0,0 +1,19 @@
+import type { CacheTraceType } from '../../../types/types.cacheLog.js';
+import type { LogType } from '../../../types/types.log.js';
+import type { SocketEventType } from '../../../types/types.socket.js';
+export type RequestTimelineEvent = {
+    kind: 'cache';
+    id: string;
+    createdAt: number;
+    cache: CacheTraceType;
+} | {
+    kind: 'log';
+    id: string;
+    createdAt: number;
+    log: LogType;
+} | {
+    kind: 'socket';
+    id: string;
+    createdAt: number;
+    socket: SocketEventType;
+};

package/dist/web/v2/components/tabs/StickyIconTabs.d.ts

@@ -0,0 +1,17 @@
+type StickyIconTabsItem = {
+    id: string;
+};
+type StickyIconTabsProps<Item extends StickyIconTabsItem> = {
+    items: Item[];
+    activeId: string | null;
+    isLoading?: boolean;
+    label?: string;
+    onSelect: (id: string) => void;
+    onAdd: () => void;
+    onClose: (id: string) => void;
+    canClose?: (length: number) => boolean;
+    renderLabel?: (item: Item) => string;
+    disabled?: boolean;
+};
+export default function StickyIconTabs<Item extends StickyIconTabsItem>({ items, activeId, isLoading, label, onSelect, onAdd, onClose, canClose, renderLabel, disabled, }: StickyIconTabsProps<Item>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+type DurationTagProps = {
+    value: number | null | undefined;
+    start: {
+        value: number;
+        color: string;
+    };
+    end: {
+        value: number;
+        color: string;
+    };
+    label?: string | null;
+    emptyLabel?: string;
+    onClick?: () => void;
+};
+export default function DurationTag({ value, start, end, label, emptyLabel, onClick, }: DurationTagProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,7 +1,6 @@
-import { LogLevel } from '../../types/types.log';
 import { ChipSelectionState } from './chip.types';
 type LogLevelChipProps = {
-    level: LogLevel;
+    level: string;
     state?: ChipSelectionState;
     selected?: boolean;
     onClick?: () => void;

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

@@ -0,0 +1,21 @@
+import type { CacheTraceQuery, CacheTraceType } from '../types/types.cacheLog.js';
+type CacheTraceFeedFilters = CacheTraceQuery & {
+    cursor?: string;
+    pageSize?: number;
+};
+export type UseCacheTraceOptions = CacheTraceFeedFilters & {
+    cacheKey: string;
+};
+type UseCacheTraceResult = {
+    traces: CacheTraceType[];
+    data: any;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: unknown;
+    refetch: () => Promise<unknown>;
+    fetchNextPage: () => Promise<unknown>;
+    hasNextPage?: boolean;
+    isFetchingNextPage?: boolean;
+};
+export declare function useCacheTrace(options: UseCacheTraceOptions | null): UseCacheTraceResult;
+export {};

package/dist/web/v2/registries/logLevelRegistry.d.ts

@@ -0,0 +1,27 @@
+export type LogLevel = string;
+export type CssColor = string;
+export type SetColorMode = 'set' | 'override';
+export declare const DEFAULT_LEVEL_COLORS: {
+    readonly info: "#42a5f5";
+    readonly warning: "#ffa726";
+    readonly error: "#ef5350";
+    readonly debug: "#ab47bc";
+    readonly trace: "#26a69a";
+};
+/** Non-react snapshot getters (use hooks below if you need reactivity). */
+export declare const getSeenLevels: () => string[];
+export declare const getLevelColor: (level: LogLevel, fallback?: CssColor) => string;
+export declare const getLevelColorMap: () => Readonly<Record<string, CssColor>>;
+/**
+ * Tracks levels discovered from the API and persists them.
+ * Levels are normalized to lower-case.
+ */
+export declare const trackSeenLevels: (levels: Iterable<string>) => void;
+/**
+ * Sets (or overrides) the color for a level.
+ * - mode="set": only sets if no color exists yet
+ * - mode="override": always replaces existing value
+ */
+export declare const setLevelColor: (level: LogLevel, color: CssColor, mode?: SetColorMode) => boolean;
+export declare const useSeenLogLevels: () => string[];
+export declare const useLogLevelColor: (level: LogLevel, fallback?: CssColor) => CssColor;

package/dist/web/v2/stores/playgroundStore.d.ts

@@ -1,14 +1,8 @@
 import { ReactNode } from 'react';
 import type { MethodType } from '../types/types.base';
-import type { SerializableSchema, EndpointType } from '../types/types.endpoint';
-export type PlaygroundKeyValueRow = {
-    id: string;
-    key: string;
-    value: string;
-    enabled: boolean;
-    typeHint?: string;
-    description?: string;
-};
+import type { EndpointType, SerializableSchema } from '../types/types.endpoint';
+import type { KeyValueRow } from '../types/types.kvRow.js';
+export type PlaygroundKeyValueRow = KeyValueRow;
 export type PlaygroundRunRecord = {
     id: string;
     method: MethodType;

package/dist/web/v2/theme.d.ts

@@ -18,4 +18,25 @@ declare module '@mui/material/styles' {
         status?: Palette['status'];
     }
 }
+export type DocsUiSeeds = {
+    bg: string;
+    surface: string;
+    primary: string;
+    secondary: string;
+    success: string;
+    warning: string;
+    error: string;
+    textPrimary: string;
+};
+export declare const defaultUi: {
+    readonly bg: "#0B0D10";
+    readonly surface: "#141922";
+    readonly primary: "#FF9F66";
+    readonly secondary: "#5A9BFF";
+    readonly success: "#22C58A";
+    readonly warning: "#FFC24D";
+    readonly error: "#FF4D5E";
+    readonly textPrimary: "#F7FAFF";
+};
+export declare function createDocsTheme(overrides?: Partial<DocsUiSeeds>): import("@mui/material").Theme;
 export declare const docsTheme: import("@mui/material").Theme;